diff --git a/liberty/.clangd b/liberty/.clangd
index 9e4ac78e..0f1417b8 100644
--- a/liberty/.clangd
+++ b/liberty/.clangd
@@ -1,5 +1,5 @@
 CompileFlags:                     # Tweak the parse settings
-  Add: [-Wold-style-cast]                   # treat all files as C++, enable more warnings
+  Add: [-Wold-style-cast, -Wunused-variable, -Wsigned-compare]                   # treat all files as C++, enable more warnings
 Diagnostics:
   ClangTidy:
     Add: bugprone-*
diff --git a/liberty/include/liberty/SLAMP/SLAMP.h b/liberty/include/liberty/SLAMP/SLAMP.h
index 5a9c66bd..942ada53 100644
--- a/liberty/include/liberty/SLAMP/SLAMP.h
+++ b/liberty/include/liberty/SLAMP/SLAMP.h
@@ -49,6 +49,7 @@ class SLAMP: public ModulePass
   void instrumentDestructor(Module& m);
   void instrumentGlobalVars(Module& m, Function* ctor);
   void instrumentAllocas(Module& m);
+  void instrumentBasePointer(Module &m, Loop *l);
 
   // functions used in instrumentAllocas
   void findLifetimeMarkers(Value* i, set<const Value*>& already, std::vector<Instruction*>& starts, std::vector<Instruction*>& ends);
@@ -58,7 +59,8 @@ class SLAMP: public ModulePass
 
   void instrumentNonStandards(Module& m, Function* ctor);
   void allocErrnoLocation(Module& m, Function* ctor);
-
+  void instrumentLoopStartStopForAll(Module &m);
+  void instrumentFunctionStartStop(Module&m);
   void instrumentLoopStartStop(Module&m, Loop* l);
   void instrumentInstructions(Module& m, Loop* l);
 
diff --git a/liberty/lib/Repl/ReplParse.hpp b/liberty/lib/Repl/ReplParse.hpp
index 5c89af74..717142cc 100644
--- a/liberty/lib/Repl/ReplParse.hpp
+++ b/liberty/lib/Repl/ReplParse.hpp
@@ -18,6 +18,7 @@ enum ReplAction {
   RemoveAll,
   Parallelize,
   Modref,
+  Save,
   Unknown = -1
 };
 
@@ -45,6 +46,7 @@ const map<string, ReplAction> ReplActions = {
   {"parallelize", ReplAction::Parallelize},
   {"p", ReplAction::Parallelize},
   {"modref", ReplAction::Modref},
+  {"save", ReplAction::Save}
 };
 
 // a helper to get the vocabulary of Repl, to help the auto completion
@@ -70,6 +72,7 @@ const map<ReplAction, string> HelpText = {
   {RemoveAll, "removeAll/ra $inst_id: \tremove all dependences from and to a instruction from the loop"},
   {Parallelize, "paralelize/p: \tparallelize the selected loop with current dependences"},
   {Modref, "modref/mr $inst_id1, $inst_id2: \tquery the modref between two instructions"},
+  {Save, "save $filename:  \tsave the loop to a file"},
   {Quit, "quit/q: quit the repl"},
 };
 
diff --git a/liberty/lib/Repl/repl.cpp b/liberty/lib/Repl/repl.cpp
index 29d8b1d5..e4d4a655 100644
--- a/liberty/lib/Repl/repl.cpp
+++ b/liberty/lib/Repl/repl.cpp
@@ -1,8 +1,8 @@
 #include "liberty/LoopProf/Targets.h"
 #include "liberty/Orchestration/Orchestrator.h"
 #include "liberty/Orchestration/PSDSWPCritic.h"
-#include "liberty/Speculation/PDGBuilder.hpp"
 #include "liberty/Strategy/ProfilePerformanceEstimator.h"
+#include "scaf/Utilities/ModuleLoops.h"
 #include "scaf/Utilities/ReportDump.h"
 #include "scaf/Utilities/Metadata.h"
 #include "llvm/Pass.h"
@@ -22,399 +22,182 @@
 #include "noelle/core/PDG.hpp"
 #include "noelle/core/PDGPrinter.hpp"
 #include "noelle/core/SCCDAG.hpp"
+#include "noelle/core/LoopDependenceInfo.hpp"
 #include "ReplParse.hpp"
 
+#include "noelle/tools/Repl.hpp"
+
 using namespace llvm;
 using namespace std;
 using namespace liberty;
 using namespace llvm::noelle;
 
-class OptRepl : public ModulePass {
+cl::opt<string> HistoryFileName("cpf-repl-history", cl::desc("Specify command history file name"), cl::init(""));
+
+class CpfRepl : public ModulePass {
   public:
     static char ID;
     void getAnalysisUsage(AnalysisUsage &au) const;
-    StringRef getPassName() const { return "remed-selector"; }
+    StringRef getPassName() const { return "cpf-repl"; }
     bool runOnModule(Module &M);
-    OptRepl() : ModulePass(ID) {}
+    CpfRepl() : ModulePass(ID) {}
 };
 
-char OptRepl::ID = 0;
-static RegisterPass<OptRepl> rp("opt-repl", "Opt Repl");
+char CpfRepl::ID = 0;
+static RegisterPass<CpfRepl> rp("cpf-repl", "CPF Repl");
 
-void OptRepl::getAnalysisUsage(AnalysisUsage &au) const {
+void CpfRepl::getAnalysisUsage(AnalysisUsage &au) const {
+  au.addRequired<Noelle>();
   au.addRequired<ModuleLoops>();
   au.addRequired<Targets>();
-  au.addRequired<PDGBuilder>();
   au.addRequired< LoopProfLoad >();
   au.addRequired< ProfilePerformanceEstimator >();
-  au.addRequired<LoopAA>();
+  au.addRequired< LoopInfoWrapperPass >();
   au.setPreservesAll();
 }
 
-typedef map<unsigned, DGNode<Value> *> InstIdMap_t;
-typedef map<DGNode<Value> *, unsigned> InstIdReverseMap_t;
-typedef map<unsigned, DGEdge<Value> *> DepIdMap_t;
-typedef map<DGEdge<Value> *, uint32_t> DepIdReverseMap_t;
-
-// helper function to generate
-static unique_ptr<InstIdMap_t> createInstIdMap(PDG *pdg) {
-  auto instIdMap = std::make_unique<InstIdMap_t>();
-  unsigned instId = 0;
-  for (auto &instNode : pdg->getNodes()) {
-    instIdMap->insert(make_pair(instId, instNode));
-    instId++;
-  }
-
-  return instIdMap;
-}
-
-static unique_ptr<InstIdReverseMap_t> createInstIdLookupMap(InstIdMap_t m) {
-  auto lookupMap = std::make_unique<InstIdReverseMap_t>();
-  for (auto &[instId, node] : m) {
-    lookupMap->insert(make_pair(node, instId));
-  }
-
-  return lookupMap;
-}
-
-static shared_ptr<DepIdReverseMap_t> createDepIdLookupMap(DepIdMap_t m) {
-  auto lookupMap = std::make_shared<DepIdReverseMap_t>();
-  for (auto &[instId, node] : m) {
-    lookupMap->insert(make_pair(node, instId));
-  }
-
-  return lookupMap;
-}
-
-// a simple autocompletion generator
-char* completion_generator(const char* text, int state) {
-  // This function is called with state=0 the first time; subsequent calls are
-  // with a nonzero state. state=0 can be used to perform one-time
-  // initialization for this completion session.
-  static std::vector<std::string> matches;
-  static size_t match_index = 0;
-
-  if (state == 0) {
-    // During initialization, compute the actual matches for 'text' and keep
-    // them in a static vector.
-    matches.clear();
-    match_index = 0;
-
-    // Collect a vector of matches: vocabulary words that begin with text.
-    std::string textstr = std::string(text);
-    for (auto word : ReplVocab) {
-      if (word.size() >= textstr.size() &&
-          word.compare(0, textstr.size(), textstr) == 0) {
-        matches.push_back(word);
-      }
+class CpfReplDriver: public Repl::ReplDriver {
+  private:
+    LoopAA* loopAA;
+    const Targets &targets;
+    ModuleLoops &mloops;
+    vector<LoopAA*> loopAAs;
+    Pass &pass;
+    vector<bool> loopAAEnabled;
+
+    Loop *getSelectedLLVMLoop() {
+      auto loops = &pass.getAnalysis<LoopInfoWrapperPass>(*selectedLoop->getLoopStructure()->getFunction()).getLoopInfo();
+      auto loop = loops->getLoopFor(selectedLoop->getLoopStructure()->getHeader());
+      return loop;
     }
-  }
-
-  if (match_index >= matches.size()) {
-    // We return nullptr to notify the caller no more matches are available.
-    return nullptr;
-  } else {
-    // Return a malloc'd char* for the match. The caller frees it.
-    return strdup(matches[match_index++].c_str());
-  }
-}
-
-char** completer(const char* text, int start, int end) {
-  // Don't do filename completion even if our generator finds no matches.
-  rl_attempted_completion_over = 1;
-
-  // Note: returning nullptr here will make readline use the default filename
-  // completer.
-  return rl_completion_matches(text, completion_generator);
-}
 
+  public:
+    CpfReplDriver(Noelle &noelle, Module &m, LoopAA* loopAA, const Targets &targets, ModuleLoops &mloops, Pass &pass) : ReplDriver(noelle, m), loopAA(loopAA), targets(targets), mloops(mloops), pass(pass) {
+      // initialize loop aa
+      auto aa = loopAA;
+      while (aa) {
+        loopAAs.push_back(aa);
+        aa = aa->getNextAA();
+      }
+      unsigned numLoopAAs = loopAAs.size();
+      loopAAEnabled = vector<bool>(numLoopAAs, true);
 
-bool OptRepl::runOnModule(Module &M) {
-  bool modified = false;
-
-  ModuleLoops &mloops = getAnalysis<ModuleLoops>();
-  const Targets &targets = getAnalysis<Targets>();
-  PDGBuilder &pdgbuilder = getAnalysis<PDGBuilder>();
-
-  // store the loopID
-  map<unsigned, Loop *> loopIdMap;
-
-  // the selected information
-  llvm::Function *selectedFunction; // TODO: not used yet
-  Loop *selectedLoop;
-  unique_ptr<PDG> selectedPDG;
-  unique_ptr<SCCDAG> selectedSCCDAG;
-
-  unique_ptr<InstIdMap_t> instIdMap;
-  unique_ptr<InstIdReverseMap_t> instIdLookupMap;
-  unique_ptr<DepIdMap_t> depIdMap;
-  shared_ptr<DepIdReverseMap_t> depIdLookupMap;
-
-  // prepare hot loops from the targets
-  {
-    unsigned loopId = 0;
-    for (Targets::iterator i = targets.begin(mloops), e = targets.end(mloops);
-         i != e; ++i) {
-      Loop *loop = *i;
-      loopIdMap[loopId++] = loop;
-      continue;
+      outs() << "LoopAA (" << numLoopAAs << "): ";
+      loopAA->dump();
     }
-  }
 
-  rl_attempted_completion_function = completer;
-  // the main repl while loop
-  while (true) {
-    string query;
-    char *buf = readline("(opt-repl) ");
-    query = (const char *)(buf);
-    if (query.size() > 0) {
-      add_history(buf);
-      free(buf); // free the buf readline created
+    string prompt() override {
+      stringstream ss;
+      ss << "(cpf-repl";
+      if (selectedLoopId != -1)
+        ss << " loop " << selectedLoopId;
+      ss << ") ";
+      return ss.str();
     }
 
-    // check if it's quit or unknown
-    ReplParser parser(query);
-    if (parser.getAction() == ReplAction::Quit)
-      break;
-
-    if (parser.getAction() == ReplAction::Unknown) {
-      outs() << "Unknown command!\n";
-      continue;
+    void createLoopMap() override {
+
+      outs() << "CPF create loop map\n";
+      
+      // prepare hot loops from the targets
+      unsigned loopId = 0;
+      for (Targets::iterator i = targets.begin(mloops), e = targets.end(mloops);
+          i != e; ++i) {
+        Loop *loop = *i;
+        LoopStructure loopStructure(loop);
+        auto ldi = noelle.getLoop(&loopStructure);
+        loopIdMap[loopId++] = ldi;
+        continue;
+      }
     }
 
-    // print all loops
-    auto loopsFn = [&loopIdMap]() {
+    void loopsFn() override {
+
       outs() << "List of hot loops:\n";
 
-      for (auto &[loopId, loop] : loopIdMap) {
-        outs() << loopId << ": " << loop->getHeader()->getParent()->getName()
-               << "::" << loop->getHeader()->getName() << '\n';
-      }
-    };
+      auto &load = pass.getAnalysis< LoopProfLoad >();
 
-    // select one loop
-    auto selectFn = [&loopIdMap, &parser, &selectedLoop, &selectedPDG, &selectedSCCDAG, &pdgbuilder, &instIdMap, &instIdLookupMap]() {
-      int loopId = parser.getActionId();
-      if (loopId == -1) {
-        outs() << "No number specified\n";
-        return;
-      }
+      for (auto &[loopId, loop] : loopIdMap) {
+        auto header = loop->getLoopStructure()->getHeader();
+        // get loop id and print it
+        outs() << loopId;
 
-      if (loopIdMap.find(loopId) == loopIdMap.end()) {
-        outs() << "Loop " << loopId << " does not exist\n";
-        return;
-      }
+        auto loopNamerId = Namer::getBlkId(header);
+        if (loopNamerId != -1)
+          outs() << " (" << loopNamerId << ")";
 
-      Loop *loop = loopIdMap[loopId];
-      outs() << "Selecting loop " << loopId << ": ";
-      outs() << loop->getHeader()->getParent()->getName()
-             << "::" << loop->getHeader()->getName() << '\n';
-      selectedLoop = loop;
 
-      selectedPDG = pdgbuilder.getLoopPDG(loop);
-      selectedSCCDAG = std::make_unique<SCCDAG>(selectedPDG.get());
+        outs() << ": " << header->getName()
+          << "::" << header->getName();
+        Instruction *term = header->getTerminator();
+        if (term)
+          liberty::printInstDebugInfo(term);
 
-      instIdMap = createInstIdMap(selectedPDG.get());
-      instIdLookupMap = createInstIdLookupMap(*instIdMap);
-    };
+        char percent[10];
+        const unsigned long loop_time = load.getLoopTime(header);
 
-    // show help
-    auto helpFn = [&parser]() {
-      string action = parser.getStringAfterAction();
-      if (ReplActions.find(action) != ReplActions.end()) {
-        outs() << HelpText.at(ReplActions.at(action)) << "\n";
-      }
-      else {
-        for (auto &[action, explaination] : HelpText) {
-          outs() << explaination << "\n";
-        }
+        snprintf(percent,10, "%.1f", 100.0 * loop_time / load.getTotTime());
+        errs() << "\tTime " << loop_time << " / " << load.getTotTime()
+          << " Coverage: " << percent << "%\n";
       }
-    };
-
-    // early checks for several actions that do not need the loop set
-    if (parser.getAction() == ReplAction::Loops) {
-      loopsFn();
-      continue;
     }
 
-    if (parser.getAction() == ReplAction::Select) {
-      selectFn();
-      continue;
-    }
+    void instsFn() override {
 
-    if (parser.getAction() == ReplAction::Help){
-      helpFn();
-      continue;
-    }
-
-    // after this assume the loop has been selected
-    if (!selectedLoop) {
-      outs() << "No loops selected\n";
-      continue;
-    }
-
-    // dump information about the loop
-    auto dumpFn = [&parser, &selectedLoop, &selectedPDG, &selectedSCCDAG]() {
-      outs() << *selectedLoop;
-      outs() << "Number of instructions: "
-             << selectedPDG->getNumberOfInstructionsIncluded() << "\n";
-      outs() << "Number of dependences: "
-             << selectedPDG->getNumberOfDependencesBetweenInstructions()
-             << "\n";
-      outs() << "Number of SCCs: " << selectedSCCDAG->numNodes();
-
-      outs() << "\n";
-
-      if (parser.isVerbose()) {
-        for (auto block : selectedLoop->getBlocks()) {
-          outs() << *block;
-        }
-      }
-      outs() << "\n";
-    };
-
-    // show instructions with id
-    auto instsFn = [&parser, &instIdMap]() {
       auto printDebug = parser.isVerbose();
-      for (auto &[instId, node] : *instIdMap) {
-        auto *inst = dyn_cast<Instruction>(node->getT());
-        // not an instruction
-        if (!inst) {
-          outs() << instId << "\t" << *node->getT() << "\n";
-          continue;
-        }
-
-        auto instNamerId = Namer::getInstrId(inst);
-        outs() << instId << " (" << instNamerId << ")\t" << *node->getT();
-
-        if (printDebug) {
-          liberty::printInstDebugInfo(inst);
-        }
-
-        outs()<< "\n";
-      }
-    };
-
-    // helper function for dumping edge
-    auto dumpEdge = [&instIdLookupMap](unsigned depId, DGEdge<Value> *edge) {
-      auto idA = instIdLookupMap->at(edge->getOutgoingNode());
-      auto idB = instIdLookupMap->at(edge->getIncomingNode());
-      outs() << depId << "\t" << idA << "->" << idB << ":\t" << edge->toString() << (edge->isLoopCarriedDependence() ? "(LC)" : "(LL)")
-             << "\n";
-    };
-
-    // show all deps with id; also generate a currentPDG.dot file, the edge number is annotated on the PDG
-    auto depsFn = [&instIdLookupMap, &parser, &depIdMap, &depIdLookupMap, &selectedPDG, &dumpEdge, &instIdMap]() {
-      int fromId = parser.getFromId();
-      int toId = parser.getToId();
-      if (fromId != -1) {
-        if (instIdMap->find(fromId) == instIdMap->end()) {
-          outs() << "From InstId " << fromId<< " not found\n";
-          return;
-        }
-      }
-
-      if (toId != -1) {
-        if (instIdMap->find(toId) == instIdMap->end()) {
-          outs() << "To InstId " << toId<< " not found\n";
-          return;
+      int queryInstId = parser.getActionId();
+
+      // print the selected instruction
+      if (queryInstId != -1) {
+        bool found = false;
+        for (auto &[instId, node] : *instIdMap) {
+          auto *inst = dyn_cast<Instruction>(node->getT());
+          auto instNamerId = Namer::getInstrId(inst);
+          if (queryInstId == instNamerId) {
+            outs() << instId << " (" << queryInstId << ")\t" << *inst;
+            if (printDebug) {
+              liberty::printInstDebugInfo(inst);
+            }
+            outs() << "\n";
+            found = true;
+            break;
+          }
         }
-      }
 
-      depIdMap = std::make_unique<DepIdMap_t>();
-      unsigned id = 0;
-      if (fromId == -1 && toId == -1) { // both not specified
-        for (auto &edge : selectedPDG->getEdges()) {
-          dumpEdge(id, edge);
-          depIdMap->insert(make_pair(id++, edge));
+        if (!found) {
+          outs() << "Instruction with NamerId " << queryInstId
+                 << " not found\n";
         }
-      } else if (fromId != -1 && toId != -1) { // both specified
-        auto fromNode = instIdMap->at(fromId);
-        auto toNode = instIdMap->at(toId);
-        for (auto &edge : fromNode->getOutgoingEdges()) {
-          if (edge->getIncomingNode() == toNode) {
-            dumpEdge(id, edge);
-            depIdMap->insert(make_pair(id++, edge));
+      } else { // print all instructions
+        for (auto &[instId, node] : *instIdMap) {
+          auto *inst = dyn_cast<Instruction>(node->getT());
+          // not an instruction
+          if (!inst) {
+            outs() << instId << "\t" << *node->getT() << "\n";
+            continue;
           }
-        }
-      } else if (fromId != -1) { // from is specified
-        auto node = instIdMap->at(fromId);
-        for (auto &edge : node->getOutgoingEdges()) {
-          dumpEdge(id, edge);
-          depIdMap->insert(make_pair(id++, edge));
-        }
-      } else if (toId != -1) { // to is specified
-        auto node = instIdMap->at(toId);
-        for (auto &edge : node->getIncomingEdges()) {
-          dumpEdge(id, edge);
-          depIdMap->insert(make_pair(id++, edge));
-        }
-      }
-
-      depIdLookupMap = createDepIdLookupMap(*depIdMap);
-      selectedPDG->setDepLookupMap(depIdLookupMap);
-      llvm::noelle::DGPrinter::writeClusteredGraph<PDG, Value>("currentPDG.dot", selectedPDG.get());
-    };
-
-    // remove a dependence
-    auto removeFn = [&parser, &depIdMap, &selectedPDG, &selectedSCCDAG]() {
-      int depId = parser.getActionId();
-      if (depId == -1) {
-        outs() << "No number specified\n";
-        return;
-      }
 
-      if (depIdMap->find(depId) == depIdMap->end()) {
-        outs() << "DepId" << depId << " not found\n";
-        return;
-      }
+          auto instNamerId = Namer::getInstrId(inst);
+          outs() << instId << " (" << instNamerId << ")\t" << *node->getT();
 
-      auto dep = depIdMap->at(depId);
-      selectedPDG->removeEdge(dep);
-      // update SCCDAG
-      selectedSCCDAG = std::make_unique<SCCDAG>(selectedPDG.get());
-    };
-
-    // remove all dependence from a instruction node
-    auto removeAllFromInstFn = [&parser, &instIdMap, &selectedPDG, &selectedSCCDAG]() {
-      int instId = parser.getActionId();
-      if (instId == -1) {
-        outs() << "No number specified\n";
-        return;
-      }
-
-      if (instIdMap->find(instId) == instIdMap->end()) {
-        outs() << "InstId" << instId << " not found\n";
-        return;
-      }
-
-      auto node = instIdMap->at(instId);
-      list<llvm::noelle::DGEdge<Value>*> edgesToRemove;
-      for (auto &edge : node->getOutgoingEdges()) {
-        edgesToRemove.push_back(edge);
-      }
-
-      for (auto &edge : node->getIncomingEdges()) {
-        edgesToRemove.push_back(edge);
-      }
+          if (printDebug) {
+            liberty::printInstDebugInfo(inst);
+          }
 
-      for (auto edge : edgesToRemove) {
-        selectedPDG->removeEdge(edge);
+          outs() << "\n";
+        }
       }
-      // update SCCDAG
-      selectedSCCDAG = std::make_unique<SCCDAG>(selectedPDG.get());
-    };
+    }
 
+    void parallelizeFn() override {
 
-    // try to parallelize
-    auto parallelizeFn = [&parser, this, &selectedPDG, &selectedLoop]() {
       int threadBudget = parser.getActionId();
       if (threadBudget == -1) {
         threadBudget = 28;
       }
 
-      LoopProfLoad *lpl = &getAnalysis<LoopProfLoad>();
-      auto perf = &getAnalysis<ProfilePerformanceEstimator>();
+      LoopProfLoad *lpl = &pass.getAnalysis<LoopProfLoad>();
+      auto perf = &pass.getAnalysis<ProfilePerformanceEstimator>();
 
       // initialize performance estimator
       auto psdswp = std::make_shared<PSDSWPCritic>(perf, threadBudget, lpl);
@@ -433,18 +216,23 @@ bool OptRepl::runOnModule(Module &M) {
         }
       };
 
-      check(doall, "DOALL", *selectedPDG.get(), selectedLoop);
-      check(psdswp, "PSDSWPCritic", *selectedPDG.get(), selectedLoop);
-    };
+      auto loop = getSelectedLLVMLoop();
+
+      check(doall, "DOALL", *selectedPDG.get(), loop);
+      check(psdswp, "PSDSWPCritic", *selectedPDG.get(), loop);
+    }
+
+
+    void modrefFn() override {
 
-    // modref: create a modref query and (optionally explore the loopaa stack)
-    auto modrefFn = [this, &parser, &instIdMap, &selectedLoop]() {
       int fromId = parser.getFromId();
       int toId = parser.getToId();
 
+      unsigned numLoopAAs = loopAAs.size();
+
       if (fromId == -1) {
-          outs() << "From InstId not set\n";
-          return;
+        outs() << "From InstId not set\n";
+        return;
       }
       else {
         if (instIdMap->find(fromId) == instIdMap->end()) {
@@ -454,8 +242,8 @@ bool OptRepl::runOnModule(Module &M) {
       }
 
       if (toId == -1) {
-          outs() << "To InstId not set\n";
-          return;
+        outs() << "To InstId not set\n";
+        return;
       }
       else {
         if (instIdMap->find(toId) == instIdMap->end()) {
@@ -472,48 +260,190 @@ bool OptRepl::runOnModule(Module &M) {
         return;
       }
 
-      LoopAA *aa = getAnalysis<LoopAA>().getTopAA();
+      LoopAA *aa = loopAA;
       Remedies remeds;
+      Loop *loop = getSelectedLLVMLoop();
 
       if (parser.isVerbose()) {
         // TODO: try all combination of analysis and find a setting that the result is different
+
+        // try all loopAA, from only the first one, to all of them, the last one is always NoLoopAA
+        liberty::LoopAA::ModRefResult lastRet[3] = {liberty::LoopAA::ModRef, liberty::LoopAA::ModRef, liberty::LoopAA::ModRef};
+        for (auto i = 1; i <= numLoopAAs - 1; i++) {
+          // set the first i loopAA to be enabled(loopAAEnabled[i] = true)
+          // and the rest to be disabled (loopAAEnabled[i] = false)
+          // [0~i-1]
+          for (auto j = 0; j < i; j++) {
+            loopAAEnabled[j] = true;
+          }
+
+          // [i~numLoopAAs-2]
+          for (auto j = i; j < numLoopAAs - 1; j++) {
+            loopAAEnabled[j] = false;
+          }
+          // the last one is always NoLoopAA and enabled
+          loopAAEnabled[numLoopAAs - 1] = true;
+
+          // configure the loop AAs prev and next based on the enabled/disabled setting
+          LoopAA *prev, *cur, *next;
+          prev = nullptr;
+          cur = nullptr;
+          next = nullptr;
+          // cur is the first enabled, next is the second enabled
+          for (auto j = 0; j < numLoopAAs; j++) {
+            if (loopAAEnabled[j]) {
+              // the first one
+              if (!cur) {
+                cur = loopAAs[j];
+                continue;
+              } else {
+                next = loopAAs[j];
+                cur->configure(prev, next);
+                prev = cur;
+                cur = next;
+              }
+            }
+          }
+
+          // NoLoopAA is always enabled
+          assert(cur->getLoopAAName() == "NoLoopAA");
+          cur->configure(prev, nullptr);
+
+          // aa->dump();
+          auto ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Same, toInst, loop, remeds);
+          auto red = "\033[1;31m";
+          auto green = "\033[1;32m";
+          auto reset = "\033[0m";
+          if (ret != lastRet[0]) {
+            outs() << "Modref (same) refine from " << red << lastRet[0] << reset
+                   << " to " << red << ret << reset << " with " << green
+                   << loopAAs[i - 1]->getLoopAAName() << reset << "\n";
+          }
+          lastRet[0] = ret;
+
+          ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Before, toInst, loop, remeds);
+          if (ret != lastRet[1]) {
+            outs() << "Modref (before) refine from " << red << lastRet[1] << reset
+                   << " to " << red << ret << reset << " with " << green
+                   << loopAAs[i - 1]->getLoopAAName() << reset << "\n";
+          }
+          lastRet[1] = ret;
+
+          ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::After, toInst, loop, remeds);
+          if (ret != lastRet[2]) {
+            outs() << "Modref (after) refine from " << red << lastRet[2] << reset
+                   << " to " << red << ret << reset << " with " << green
+                   << loopAAs[i - 1]->getLoopAAName() << reset << "\n";
+          }
+          lastRet[2] = ret;
+
+          // outs() << *fromInst << "->" << *toInst << ": (Same)" << ret << " with " << remeds.size() <<  " remedies\n";
+          // ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Before, toInst, loop, remeds);
+          // outs() << *fromInst << "->" << *toInst << ": (Before)" << ret << " with " << remeds.size() <<  " remedies\n";
+          // ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::After, toInst, loop, remeds);
+          // outs() << *fromInst << "->" << *toInst << ": (After)" << ret << " with " << remeds.size() <<  " remedies\n";
+        }
       }
       else {
-        auto ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Same, toInst, selectedLoop, remeds);
+        auto ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Same, toInst, loop, remeds);
         outs() << *fromInst << "->" << *toInst << ": (Same)" << ret << " with " << remeds.size() <<  " remedies\n";
-        ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Before, toInst, selectedLoop, remeds);
+        ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::Before, toInst, loop, remeds);
         outs() << *fromInst << "->" << *toInst << ": (Before)" << ret << " with " << remeds.size() <<  " remedies\n";
-        ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::After, toInst, selectedLoop, remeds);
+        ret = aa->modref(fromInst, liberty::LoopAA::TemporalRelation::After, toInst, loop, remeds);
         outs() << *fromInst << "->" << *toInst << ": (After)" << ret << " with " << remeds.size() <<  " remedies\n";
       }
-    };
+    }
+};
 
-    switch (parser.getAction()) {
-    case ReplAction::Deps:
-      depsFn();
-      break;
-    case ReplAction::Dump:
-      dumpFn();
-      break;
-    case ReplAction::Insts:
-      instsFn();
-      break;
-    case ReplAction::Remove:
-      removeFn();
-      break;
-    case ReplAction::RemoveAll:
-      removeAllFromInstFn();
-      break;
-    case ReplAction::Parallelize:
-      parallelizeFn();
-      break;
-    case ReplAction::Modref:
-      modrefFn();
+// a simple autocompletion generator
+char* completion_generator(const char* text, int state) {
+  // This function is called with state=0 the first time; subsequent calls are
+  // with a nonzero state. state=0 can be used to perform one-time
+  // initialization for this completion session.
+  static std::vector<std::string> matches;
+  static size_t match_index = 0;
+
+  if (state == 0) {
+    // During initialization, compute the actual matches for 'text' and keep
+    // them in a static vector.
+    matches.clear();
+    match_index = 0;
+
+    // Collect a vector of matches: vocabulary words that begin with text.
+    std::string textstr = std::string(text);
+    for (auto word : ReplVocab) {
+      if (word.size() >= textstr.size() &&
+          word.compare(0, textstr.size(), textstr) == 0) {
+        matches.push_back(word);
+      }
+    }
+  }
+
+  if (match_index >= matches.size()) {
+    // We return nullptr to notify the caller no more matches are available.
+    return nullptr;
+  } else {
+    // Return a malloc'd char* for the match. The caller frees it.
+    return strdup(matches[match_index++].c_str());
+  }
+}
+
+char** completer(const char* text, int start, int end) {
+  // Don't do filename completion even if our generator finds no matches.
+  rl_attempted_completion_over = 1;
+
+  // Note: returning nullptr here will make readline use the default filename
+  // completer.
+  return rl_completion_matches(text, completion_generator);
+}
+
+
+bool CpfRepl::runOnModule(Module &M) {
+  bool modified = false;
+
+  auto &noelle = getAnalysis<Noelle>();
+
+  ModuleLoops &mloops = getAnalysis<ModuleLoops>();
+  const Targets &targets = getAnalysis<Targets>();
+
+  // have a vector of all the loop aas
+  LoopAA* loopAA = (LoopAA*)getSCAFLoopAA();
+
+  CpfReplDriver driver(noelle, M, loopAA, targets, mloops, *this);
+  driver.createLoopMap();
+
+  rl_attempted_completion_function = completer;
+  // execute command history file if specified
+  string historyFileName = HistoryFileName;
+  if (historyFileName != "") {
+    read_history(historyFileName.c_str());
+    // DISCUSSION: the last command won't get executed if using 'i <
+    // history_length'
+    for (int i = history_base; i <= history_length; i++) {
+      char *buf = history_get(i)->line;
+      string query = (const char *)(buf);
+      driver.run(query);
+    }
+    clear_history();
+  }
+
+  // the main repl while loop
+  while (true) {
+    if (driver.hasTerminated()) {
       break;
-    default:
-      outs() << "SHOULD NOT HAPPEN\n";
+    }
+
+    char *buf = readline(driver.prompt().c_str());
+    if (!buf) {
+      outs() << "Quit\n";
       break;
     }
+    string query = (const char *)(buf);
+    if (query.size() > 0) {
+      add_history(buf);
+      free(buf); // free the buf readline created
+    }
+    driver.run(query);
   }
 
   return modified;
diff --git a/liberty/lib/SLAMP/CMakeLists.txt b/liberty/lib/SLAMP/CMakeLists.txt
index 4bcfe78d..2ca86ba5 100644
--- a/liberty/lib/SLAMP/CMakeLists.txt
+++ b/liberty/lib/SLAMP/CMakeLists.txt
@@ -19,3 +19,9 @@ include_directories(./)
 add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
 
 add_subdirectory(SLAMPlib/hooks)
+add_subdirectory(SLAMPnng)
+add_subdirectory(SLAMPboost)
+add_subdirectory(SLAMPatomicq)
+add_subdirectory(SLAMPstats)
+add_subdirectory(SLAMPsmtxq)
+add_subdirectory(SLAMPcustom)
diff --git a/liberty/lib/SLAMP/SLAMP.cpp b/liberty/lib/SLAMP/SLAMP.cpp
index 5189ee50..038ec622 100644
--- a/liberty/lib/SLAMP/SLAMP.cpp
+++ b/liberty/lib/SLAMP/SLAMP.cpp
@@ -3,9 +3,11 @@
 // Single Loop Aware Memory Profiler.
 //
 
-#include "llvm/IR/LLVMContext.h"
 #define DEBUG_TYPE "SLAMP"
 
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Support/raw_ostream.h"
+
 #define USE_PDG
 
 #ifdef USE_PDG
@@ -14,6 +16,8 @@
 
 #include "liberty/SLAMP/SLAMP.h"
 #include "liberty/SLAMP/externs.h"
+#include "scaf/Utilities/CallSiteFactory.h"
+#include "liberty/PointsToProfiler/Indeterminate.h"
 
 #include "llvm/IR/CFG.h"
 #include "llvm/ADT/Statistic.h"
@@ -98,7 +102,7 @@ static cl::opt<bool> UseLinearValueModule("slamp-linear-value-module", cl::init(
 static cl::opt<bool> UseConstantAddressModule("slamp-constant-address-module", cl::init(false), cl::NotHidden, cl::desc("Use address module"));
 
 // linear address module
-static cl::opt<bool> UseLinearAddressModule("slamp-linear-address-module", cl::init(false), cl::NotHidden, cl::desc("Use linear address module"));
+ static cl::opt<bool> UseLinearAddressModule("slamp-linear-address-module", cl::init(false), cl::NotHidden, cl::desc("Use linear address module"));
 
 // trace module
 static cl::opt<bool> UseTraceModule("slamp-trace-module", cl::init(false), cl::NotHidden, cl::desc("Use trace module"));
@@ -142,6 +146,7 @@ SLAMP::~SLAMP() = default;
 void SLAMP::getAnalysisUsage(AnalysisUsage &au) const {
   // au.addRequired<StaticID>(); // use static ID (requires the bitcode to be exact the same)
   au.addRequired<ModuleLoops>();
+  au.addRequired<LoopInfoWrapperPass>();
 #ifdef USE_PDG
   au.addRequired<LoopAA>();
   au.addRequired<PDGBuilder>();
@@ -191,7 +196,25 @@ Instruction* updateDebugInfo(Instruction *inserted, Instruction *location, Modul
   return inserted;
 }
 
+unordered_map<Instruction*, uint32_t> instOffsetMap;
+
+void generateInstOffset(Module &m) {
+  // generate instruction offset
+  for (auto &f : m) {
+    if (f.isDeclaration()) continue;
+    for (auto &bb : f) {
+      unsigned offsetWithinBlock = 0;
+      for (auto &inst : bb) {
+        instOffsetMap[&inst] = offsetWithinBlock++;
+      }
+    }
+  }
+}
+
 bool SLAMP::runOnModule(Module &m) {
+  // generate instruction offset
+  generateInstOffset(m);
+
   LLVMContext &ctxt = m.getContext();
 
   // frequently used types
@@ -287,21 +310,21 @@ bool SLAMP::runOnModule(Module &m) {
 
           // debug
           LLVM_DEBUG(if (Namer::getInstrId(&I) == 21182) {
-            Remedies remedies;
-            LoopAA::ModRefResult modrefIIFW = aa->modref(
-                target_inst, LoopAA::Same, &I, target_loop, remedies);
-            auto modrefIIBW = aa->modref(&I, LoopAA::Same, target_inst,
-                                         target_loop, remedies);
-            errs() << "Target inst: " << *target_inst << "\n";
-            errs() << "I: " << I << "\n";
-            // convert retLCFW to int and print
-            errs() << "retLCFW: " << (int)(retLCFW) << "\n";
-            errs() << "retLCBW: " << (int)(retLCBW) << "\n";
-            errs() << "retIIFW: " << (int)(retIIFW) << "\n";
-            errs() << "retIIBW: " << (int)(retIIBW) << "\n";
-            errs() << "modrefIIFW: " << (modrefIIFW) << "\n";
-            errs() << "modrefIIBW: " << (modrefIIBW) << "\n";
-          });
+              Remedies remedies;
+              LoopAA::ModRefResult modrefIIFW = aa->modref(
+                  target_inst, LoopAA::Same, &I, target_loop, remedies);
+              auto modrefIIBW = aa->modref(&I, LoopAA::Same, target_inst,
+                  target_loop, remedies);
+              errs() << "Target inst: " << *target_inst << "\n";
+              errs() << "I: " << I << "\n";
+              // convert retLCFW to int and print
+              errs() << "retLCFW: " << (int)(retLCFW) << "\n";
+              errs() << "retLCBW: " << (int)(retLCBW) << "\n";
+              errs() << "retIIFW: " << (int)(retIIFW) << "\n";
+              errs() << "retIIBW: " << (int)(retIIBW) << "\n";
+              errs() << "modrefIIFW: " << (modrefIIFW) << "\n";
+              errs() << "modrefIIBW: " << (modrefIIBW) << "\n";
+              });
 
           // RAW disproved for all deps
           if ((retLCFW & 0b001) && (retLCBW & 0b001) && (retIIFW & 0b001) && (retIIBW & 0b001)) {
@@ -409,7 +432,7 @@ bool SLAMP::runOnModule(Module &m) {
   std::sort(elidedLoopInstsId.begin(), elidedLoopInstsId.end());
   errs() << "Elided Hash: " << elidedHash(elidedLoopInstsId) << "\n";
 
-  // replace external function calls to wrapper function calls
+  //// replace external function calls to wrapper function calls
   replaceExternalFunctionCalls(m);
 
 
@@ -451,13 +474,18 @@ bool SLAMP::runOnModule(Module &m) {
     instrumentGlobalVars(m, ctor);
   }
 
-  if (UsePointsToModule){
+  //// FIXME: temporarily instrument alloca and base pointer for all cases 
+  // if (UsePointsToModule){
     instrumentAllocas(m);
-  }
+    // instrument all base pointer creation
+    instrumentBasePointer(m, this->target_loop);
+  // }
 
+  instrumentFunctionStartStop(m);
   instrumentMainFunction(m);
 
   instrumentLoopStartStop(m, this->target_loop);
+  instrumentLoopStartStopForAll(m);
 
   instrumentInstructions(m, this->target_loop);
 
@@ -517,7 +545,7 @@ bool SLAMP::mayCallSetjmpLongjmp(Loop *loop) {
   getCallableFunctions(loop, callables);
 
   return (find_if(callables.begin(), callables.end(), is_setjmp_or_longjmp) !=
-          callables.end());
+      callables.end());
 }
 
 void SLAMP::getCallableFunctions(Loop *loop, set<Function *> &callables) {
@@ -558,7 +586,7 @@ void SLAMP::getCallableFunctions(CallInst *ci, set<Function *> &callables) {
 
 void SLAMP::getCallableFunctions(Function *f, set<Function *> &callables) {
   for (inst_iterator ii = inst_begin(f); ii != inst_end(f); ii++) {
-      // FIXME: not only callinst are callable
+    // FIXME: not only callinst are callable
     auto *ci = dyn_cast<CallInst>(&*ii);
     if (!ci)
       continue;
@@ -587,7 +615,7 @@ void SLAMP::getFunctionsWithSign(CallInst *ci, set<Function *> matched) {
       Function::arg_iterator fai;
       CallSite::arg_iterator cai;
       for (fai = func->arg_begin(), cai = cs.arg_begin();
-           fai != func->arg_end(); fai++, cai++) {
+          fai != func->arg_end(); fai++, cai++) {
         Value *af = &*fai;
         Value *ac = *cai;
         if (af->getType() != ac->getType()) {
@@ -602,6 +630,31 @@ void SLAMP::getFunctionsWithSign(CallInst *ci, set<Function *> matched) {
   }
 }
 
+std::string getInstructionName(Instruction *inst) {
+  auto fcn = inst->getParent()->getParent();
+  auto bb = inst->getParent();
+
+  std::stringstream sout;
+  sout << fcn->getName().str() << ' ' << bb->getName().str() << ' ';
+
+  if( inst->hasName() )
+    sout << inst->getName().str();
+  else {
+    // find the offset within the block
+    sout << '$' << instOffsetMap[inst];
+  }
+  
+  return sout.str();
+}
+
+std::string getArgName(Argument *arg) {
+  Function *fcn = arg->getParent();
+
+  std::ostringstream name;
+  name << "argument " << fcn->getName().str() << " %" << arg->getArgNo();
+  return name.str();
+}
+
 // Replace external functions with SLAMP prefixed ones (SLAMP_xxx)
 // The list of SLAMP functions are given in `externs.h`
 void SLAMP::replaceExternalFunctionCalls(Module &m) {
@@ -609,18 +662,18 @@ void SLAMP::replaceExternalFunctionCalls(Module &m) {
   auto *push = cast<Function>(
       m.getOrInsertFunction("SLAMP_ext_push", Void, I32).getCallee());
   auto *pop =
-      cast<Function>(m.getOrInsertFunction("SLAMP_ext_pop", Void).getCallee());
+    cast<Function>(m.getOrInsertFunction("SLAMP_ext_pop", Void).getCallee());
 
   set<string> externs;
   for (unsigned i = 0, e = sizeof(externs_str) / sizeof(externs_str[0]); i < e;
-       i++)
+      i++)
     externs.insert(externs_str[i]);
 
   // initialize a set of external functions not to be implemented
   set<string> ignores;
   for (unsigned i = 0,
-                e = sizeof(ignore_externs_str) / sizeof(ignore_externs_str[0]);
-       i < e; i++)
+      e = sizeof(ignore_externs_str) / sizeof(ignore_externs_str[0]);
+      i < e; i++)
     ignores.insert(ignore_externs_str[i]);
 
   vector<Function *> funcs;
@@ -640,7 +693,7 @@ void SLAMP::replaceExternalFunctionCalls(Module &m) {
     if (func->isIntrinsic()) {
       // just confirm that all uses is an intrinsic instruction
       for (Value::user_iterator ui = func->user_begin(); ui != func->user_end();
-           ui++)
+          ui++)
         assert(isa<IntrinsicInst>(*ui));
       continue;
     }
@@ -650,75 +703,92 @@ void SLAMP::replaceExternalFunctionCalls(Module &m) {
 
   bool hasUnrecognizedFunction = false;
   for (auto func : funcs) {
-     string name = func->getName();
+    string name = func->getName();
+
+    // start with SLAMP_, ignore it
+    if (name.find("SLAMP_") == 0) {
+      continue;
+    }
 
-    if (externs.find(name) == externs.end()) {
-      // check if the function argument is `readnone`, then it's pure
-      if (func->hasFnAttribute(llvm::Attribute::AttrKind::ReadNone)) {
+    // find all usage of the function
+    // add a slamp_push and slamp_pop around it
+    for (auto user : func->users()) {
+      // get instruction
+      auto *inst = dyn_cast<Instruction>(user);
+      if (inst == nullptr)
         continue;
-      }
-      // start with SLAMP_, ignore it
-      if (name.find("SLAMP_") == 0) {
+
+      // make sure it's a call to the function
+      if (!isa<CallBase>(inst))
+        continue;
+      auto *cb = dyn_cast<CallBase>(inst);
+      if (cb->getCalledFunction() != func)
         continue;
-      }
 
-      errs() << "WARNING: Wrapper for external function " << name
-                        << " not implemented.\n";
-      hasUnrecognizedFunction = true;
 
-      // find all usage of the function
-      // add a slamp_push and slamp_pop around it
-      for (auto user : func->users()) {
-        // get instruction
-        auto *inst = dyn_cast<Instruction>(user);
-        if (inst == nullptr)
-          continue;
 
-        // FIXME: duplicated code as instrumentLoopInst
-        auto id = Namer:: getInstrId(inst);
-        if (id == -1) {
-          continue;
-        }
-        vector<Value *> args;
-        args.push_back(ConstantInt::get(I32, id));
-        InstInsertPt pt = InstInsertPt::Before(inst);
-        pt << updateDebugInfo(CallInst::Create(push, args), pt.getPosition(), m);
+      // FIXME: duplicated code as instrumentLoopInst
+      auto id = Namer:: getInstrId(inst);
+      if (id == -1) {
+        continue;
+      }
+      vector<Value *> args;
+      args.push_back(ConstantInt::get(I32, id));
+      InstInsertPt pt = InstInsertPt::Before(inst);
+      pt << updateDebugInfo(CallInst::Create(push, args), pt.getPosition(), m);
+      
+      errs() << "Malloc ID " << id << " : "
+        << getInstructionName(inst) << "\n";
+
+
+      if (isa<CallInst>(inst)) {
+        pt = InstInsertPt::After(inst);
+        pt << updateDebugInfo(CallInst::Create(pop), pt.getPosition(), m);
+      } else if (auto *invokeI = dyn_cast<InvokeInst>(inst)) {
+        // for invoke, need to find the two paths and add pop
+        auto insertPop = [&pop, &m](BasicBlock* entry){
+          InstInsertPt pt;
+          if (isa<LandingPadInst>(entry->getFirstNonPHI()))
+            pt = InstInsertPt::After(entry->getFirstNonPHI());
+          else
+            pt = InstInsertPt::Before(entry->getFirstNonPHI());
 
-        if (isa<CallInst>(inst)) {
-          pt = InstInsertPt::After(inst);
           pt << updateDebugInfo(CallInst::Create(pop), pt.getPosition(), m);
-        } else if (auto *invokeI = dyn_cast<InvokeInst>(inst)) {
-          // for invoke, need to find the two paths and add pop
-          auto insertPop = [&pop, &m](BasicBlock* entry){
-            InstInsertPt pt;
-            if (isa<LandingPadInst>(entry->getFirstNonPHI()))
-              pt = InstInsertPt::After(entry->getFirstNonPHI());
-            else
-              pt = InstInsertPt::Before(entry->getFirstNonPHI());
-
-            pt << updateDebugInfo(CallInst::Create(pop), pt.getPosition(), m);
-          };
-
-          insertPop(invokeI->getNormalDest());
-          // FIXME: will generate mulitiple `slamp_pop` after the landing pad
-          //        Fine for now because `slamp_pop` only set the context to 0
-          insertPop(invokeI->getUnwindDest());
+        };
 
-        } else {
-          assert(false && "Call but not CallInst nor InvokeInst");
-        }
+        insertPop(invokeI->getNormalDest());
+        // FIXME: will generate mulitiple `slamp_pop` after the landing pad
+        //        Fine for now because `slamp_pop` only set the context to 0
+        insertPop(invokeI->getUnwindDest());
+
+      } else {
+        assert(false && "Call but not CallInst nor InvokeInst");
       }
+    }
 
-    } else {
-      string wrapper_name = "SLAMP_" + name;
+    //// FIXME: temporarily turn off the replacement
+    // if (externs.find(name) == externs.end()) {
+    //   // check if the function argument is `readnone`, then it's pure
+    //   if (func->hasFnAttribute(llvm::Attribute::AttrKind::ReadNone)) {
+    //     continue;
+    //   }
+
+    //   errs() << "WARNING: Wrapper for external function " << name
+    //     << " not implemented.\n";
+    //   hasUnrecognizedFunction = true;
+
+    // } else {
+    //   string wrapper_name = "SLAMP_" + name;
       /* Function* wrapper = cast<Function>( m.getOrInsertFunction(wrapper_name,
        * func->getFunctionType() ) ); */
-      FunctionCallee wrapper =
-          m.getOrInsertFunction(wrapper_name, func->getFunctionType());
+    //   FunctionCallee wrapper =
+    //     m.getOrInsertFunction(wrapper_name, func->getFunctionType());
+
+    //   // replace 'func' to 'wrapper' in uses
+    //   func->replaceAllUsesWith(wrapper.getCallee());
+    // }
+
 
-      // replace 'func' to 'wrapper' in uses
-      func->replaceAllUsesWith(wrapper.getCallee());
-    }
   }
 
   if (hasUnrecognizedFunction) {
@@ -891,11 +961,135 @@ void SLAMP::reportEndOfAllocaLifetime(AllocaInst *inst, Instruction *end, bool e
   else {
     //TODO:search for terminator block 
     auto *F = inst->getFunction();
+
+    // find all return instructions
     //IRBuilder<> Builder();
   }
   return;
 }
 
+/// For each pointer use in the targeted loop
+/// 1. find the base pointer
+/// 2. Go to the creation time of the pointer
+/// 3. Insert a call to SLAMP_report_base_pointer(instruction, address)
+void SLAMP::instrumentBasePointer(Module &m, Loop* l) {
+
+  const DataLayout &DL = m.getDataLayout();
+
+  auto *find_underlying_arg = cast<Function>(
+      m.getOrInsertFunction("SLAMP_report_base_pointer_arg", Void, I32, I32, I8Ptr)
+      .getCallee());
+  auto *find_underlying_inst = cast<Function>(
+      m.getOrInsertFunction("SLAMP_report_base_pointer_inst", Void, I32, I8Ptr)
+      .getCallee());
+
+  // collect all pointer use by load, store, function argument in the targeted loop
+  std::set<const Value*> indeterminate_pointers, indeterminate_objects, already;
+
+  for (auto &F : m) {
+    for (auto &BB : F) {
+      Indeterminate::findIndeterminateObjects(BB, indeterminate_pointers, indeterminate_objects);
+    }
+  }
+
+  // for(auto *bb: l->getBlocks())
+  // {
+    // Indeterminate::findIndeterminateObjects(*bb, indeterminate_pointers, indeterminate_objects);
+  // }
+
+  for (auto &object : indeterminate_objects) {
+    if (const auto *const_arg = dyn_cast<Argument>(object)) {
+      if (already.count(const_arg))
+        continue;
+      already.insert(const_arg);
+
+      LLVM_DEBUG(
+          errs()
+          << "Instrumenting indeterminate base object in function argument "
+          << *const_arg << "\n");
+
+      auto *arg = const_cast<Argument *>(const_arg);
+      Function *fcn = arg->getParent();
+
+      Instruction *cast = new BitCastInst(arg, I8Ptr);
+      auto fcnId = Namer::getFuncId(fcn);
+      auto argId = arg->getArgNo();
+
+      auto pt = InstInsertPt::Beginning(fcn);
+      Value *args[] = {ConstantInt::get(I32, fcnId),
+                       ConstantInt::get(I32, argId), cast};
+      pt << cast
+         << updateDebugInfo(CallInst::Create(find_underlying_arg, args),
+                            pt.getPosition(), m);
+
+      // errs() << "UO Arg (" << fcnId << "," << argId <<  ") : "  
+      errs() << "UO Arg " << (fcnId << 5 | ((0x1f & (argId << 4)) | 0x1)) << " : "
+        << getArgName(arg) << "\n";
+    }
+    else if (const auto *const_inst = dyn_cast<Instruction>(object)) {
+      if (already.count(const_inst))
+        continue;
+      already.insert(const_inst);
+
+      if (isa<AllocaInst>(const_inst))
+        continue;
+
+      LLVM_DEBUG(errs() << "Instrumenting indeterminate base object: "
+                        << *const_inst << '\n');
+      auto *inst = const_cast<Instruction *>(const_inst);
+
+      Instruction *cast = new BitCastInst(inst, I8Ptr);
+
+      InstInsertPt where;
+      if (auto *invoke = dyn_cast<InvokeInst>(inst)) {
+        auto entry = invoke->getNormalDest();
+        if (isa<LandingPadInst>(entry->getFirstNonPHI())) {
+          where = InstInsertPt::After(entry->getFirstNonPHI());
+        }
+        else {
+          // iterate all the phi node in the entry block
+          // if inst is one of the incoming value of the phi node
+          // then convert the cast to the phi node
+          for (auto &phi : entry->phis()) {
+            bool found = false;
+            for (auto &incoming : phi.incoming_values()) {
+              if (incoming == inst) {
+                // replace the cast with the phi node
+                cast->deleteValue();
+                cast = new BitCastInst(&phi, I8Ptr);
+                found = true;
+                break;
+              }
+            }
+            if (found)
+              break;
+          }
+          where = InstInsertPt::Before(entry->getFirstNonPHI());
+        }
+      } else if (auto *phi = dyn_cast<PHINode>(inst)) {
+        // Don't accidentally insert instrumentation before
+        // later PHIs or landing pad instructions.
+        where = InstInsertPt::Beginning(phi->getParent());
+      } else
+        where = InstInsertPt::After(inst);
+
+      auto instId = Namer::getInstrId(inst);
+      Value *args[] = {
+        ConstantInt::get(I32, instId),
+        cast
+      };
+      where << cast 
+        << updateDebugInfo(CallInst::Create(find_underlying_inst, args), where.getPosition(), m);
+
+      errs() << "UO Inst " << (instId << 1 | 0x0) << " : " << getInstructionName(inst) << "\n";
+    }
+    else {
+      errs() << "What is: " << *object << '\n';
+      assert(false && "Unknown object type?!?!");
+    }
+  }
+}
+
 // For each alloca, find the lifetime starts and ends
 // and insert calls to `SLAMP_callback_stack_alloca` and
 // `SLAMP_callback_stack_free`
@@ -1055,6 +1249,155 @@ void SLAMP::instrumentMainFunction(Module &m) {
   }
 }
 
+/// Pass in the loop and instrument enter/exit hooks
+void SLAMP::instrumentLoopStartStopForAll(Module &m) {
+
+  // for all functions
+  for (auto &f : m) {
+    if (f.isDeclaration())
+      continue;
+    // get all loops
+    LoopInfo &li = getAnalysis<LoopInfoWrapperPass>(f).getLoopInfo();
+    for (auto &loop : li.getLoopsInPreorder()) {
+
+      // TODO: check setjmp/longjmp
+      BasicBlock *header = loop->getHeader();
+      auto loopId = Namer::getBlkId(header);
+      if (loopId == -1) {
+        assert(false && "Loop header has no id");
+      }
+      BasicBlock *latch = loop->getLoopLatch();
+      vector<Value *> args;
+      args.push_back(ConstantInt::get(I32, loopId));
+
+      errs() << "Loop ID " << loopId << " : " << f.getName() << " " << header->getName() << " " << li.getLoopDepth(header) << "\n";
+
+      // check if loop-simplify pass executed
+      assert(loop->getNumBackEdges() == 1 &&
+          "Should be only 1 back edge, loop-simplify?");
+      assert(latch && "Loop latch needs to exist, loop-simplify?");
+
+      // add instrumentation on loop header:
+      // if new invocation, call SLAMP_loop_invocation, else, call
+      // SLAMP_loop_iteration
+      auto *f_loop_invoke = cast<Function>(
+          m.getOrInsertFunction("SLAMP_enter_loop", Void, I32).getCallee());
+      auto *f_loop_iter= cast<Function>(
+          m.getOrInsertFunction("SLAMP_loop_iter_ctx", Void, I32).getCallee());
+      auto *f_loop_exit = cast<Function>(
+          m.getOrInsertFunction("SLAMP_exit_loop", Void, I32).getCallee());
+
+      PHINode *funcphi = PHINode::Create(f_loop_invoke->getType(), 2, "funcphi_loop_context");
+      InstInsertPt pt;
+
+      if (isa<LandingPadInst>(header->getFirstNonPHI()))
+        pt = InstInsertPt::After(header->getFirstNonPHI());
+      else
+        pt = InstInsertPt::Before(header->getFirstNonPHI());
+
+      pt << funcphi;
+
+      // choose which function to execute (iter or invoke)
+      for (auto pred : predecessors(header)) {
+        if (pred == latch)
+          funcphi->addIncoming(f_loop_iter, pred);
+        else
+          funcphi->addIncoming(f_loop_invoke, pred);
+      }
+
+      updateDebugInfo(CallInst::Create(funcphi, args, "", header->getFirstNonPHI()), header->getFirstNonPHI(), m);
+
+      // Add `SLAMP_loop_exit` to all loop exits
+      SmallVector<BasicBlock *, 8> exits;
+      loop->getExitBlocks(exits);
+
+      // one instrumentation per block
+      set<BasicBlock *> s;
+
+      for (unsigned i = 0; i < exits.size(); i++) {
+        if (s.count(exits[i]))
+          continue;
+
+        CallInst *ci = CallInst::Create(f_loop_exit, args);
+
+        InstInsertPt pt2;
+        if (isa<LandingPadInst>(exits[i]->getFirstNonPHI()))
+          pt2 = InstInsertPt::After(exits[i]->getFirstNonPHI());
+        else
+          pt2 = InstInsertPt::Before(exits[i]->getFirstNonPHI());
+
+        pt2 << updateDebugInfo(ci, pt2.getPosition(), m);
+
+        s.insert(exits[i]);
+      }
+    }
+  }
+
+}
+
+
+/// Instrumnent each function entry and exit with SLAMP function entry and exit calls
+void SLAMP::instrumentFunctionStartStop(Module &m) {
+  // for each function body
+  for (auto &fi : m) {
+    Function *func = &fi;
+    if (func->isDeclaration())
+      continue;
+
+    // ignore all SLAMP calls
+    if (func->getName().startswith("SLAMP_"))
+      continue;
+
+
+    // find function ID
+    auto fcnID = Namer::getFuncId(func);
+    if (fcnID == -1) {
+      errs() << "Cannot find function ID for " << func->getName() << "\n";
+      continue;
+    }
+
+    errs() << "Function ID " << fcnID << " : " << func->getName() << "\n";
+
+    // set parameters
+    vector<Value *> args;
+    args.push_back(ConstantInt::get(I32, fcnID));
+
+    // find the function entry
+    auto *f_function_entry = cast<Function>(
+      m.getOrInsertFunction("SLAMP_enter_fcn", Void, I32).getCallee());
+    auto *f_function_exit = cast<Function>(
+      m.getOrInsertFunction("SLAMP_exit_fcn", Void, I32).getCallee());
+
+    // insert SLAMP_enter_fcn at the beginning of the function
+    BasicBlock *entry = &(func->getEntryBlock());
+    InstInsertPt pt = InstInsertPt::Before(entry->getFirstNonPHI());
+    pt << updateDebugInfo(CallInst::Create(f_function_entry, args), pt.getPosition(), m);
+
+    // find all exits of the function
+    vector<Instruction *> exits;
+    for (auto &bi : *func) {
+      BasicBlock *bb = &bi;
+      if (isa<ReturnInst>(bb->getTerminator()))
+        exits.push_back(bb->getTerminator());
+      // else if (isa<ResumeInst>(bb->getTerminator()))
+        // exits.push_back(bb->getTerminator());
+        // // FIXME: should be at the beginning of the block
+      // else if (isa<UnreachableInst>(bb->getTerminator()))
+        // exits.push_back(bb->getTerminator());
+      //// FIXME: invoke the exception end
+      // else if (isa<InvokeInst>(bb->getTerminator()))
+        // exits.push_back(bb->getTerminator());
+    }
+
+    // insert SLAMP_exit_fcn at the end of the function
+    for (auto &exit : exits) {
+      InstInsertPt pt = InstInsertPt::Before(exit);
+      pt << updateDebugInfo(CallInst::Create(f_function_exit, args), pt.getPosition(), m);
+    }
+
+  }
+}
+
 /// Pass in the loop and instrument invocation/iteration/exit hooks
 void SLAMP::instrumentLoopStartStop(Module &m, Loop *loop) {
   // TODO: check setjmp/longjmp
diff --git a/liberty/lib/SLAMP/SLAMPatomicq/AtomicQueueSend.cpp b/liberty/lib/SLAMP/SLAMPatomicq/AtomicQueueSend.cpp
new file mode 100644
index 00000000..2b684d73
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPatomicq/AtomicQueueSend.cpp
@@ -0,0 +1,376 @@
+#include "slamp_hooks.h"
+#include <boost/lockfree/spsc_queue.hpp> // ring buffer
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+#include <iostream>
+
+#include "atomic_queue/atomic_queue.h"
+
+namespace bip = boost::interprocess;
+namespace shm
+{
+
+    using Element = char; // Queue element type.
+    using char_alloc = bip::allocator<Element, bip::managed_shared_memory::segment_manager>;
+    Element constexpr NIL = static_cast<Element>(-1); // Atomic elements require a special value that cannot be pushed/popped.
+    // using Queue = atomic_queue::AtomicQueueB<Element, std::allocator<Element>, NIL>; // Use heap-allocated buffer.
+    // using Queue = atomic_queue::AtomicQueueB<Element, char_alloc, NIL>; // Use heap-allocated buffer.
+    using Queue = atomic_queue::AtomicQueueB<Element, std::allocator<Element>, NIL, false, false, true>;
+
+}
+
+#include <unistd.h>
+
+
+// create segment and corresponding allocator
+bip::managed_shared_memory *segment;
+shm::char_alloc *char_alloc;
+
+shm::Queue *queue;
+unsigned long counter4 = 0;
+unsigned long counter8 = 0;
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+  segment = new bip::managed_shared_memory(bip::open_or_create, "MySharedMemory", 65536UL*1600);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  auto q = static_cast<void *>(segment->find_or_construct<char>("atomic_queue")[65536]());
+  queue = new shm::Queue(65536, q);
+
+
+  queue->push((char)fn_id);
+  // send a msg with "fn_id, loop_id"
+  // char msg[100];
+  // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // a_queue->push(msg);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter4 << " " << counter8 << std::endl;
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){}
+void SLAMP_exit_fcn(uint32_t id){}
+void SLAMP_enter_loop(uint32_t id){}
+void SLAMP_exit_loop(uint32_t id){}
+void SLAMP_loop_iter_ctx(uint32_t id){}
+void SLAMP_loop_invocation(){}
+void SLAMP_loop_iteration(){}
+void SLAMP_loop_exit(){}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter4++;
+  // char msg[] = "load4";
+  // queue->push(shm::shared_string(msg, *char_alloc));
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter8++;
+  queue->push((char)instr);
+  // char msg[1] = {8};
+  // // // sprintf(msg, "load8,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){}
+void SLAMP_store2(uint32_t instr, const uint64_t addr){}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){}
+static void SLAMP_free_hook(void *ptr, const void *caller){}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPatomicq/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPatomicq/CMakeLists.txt
new file mode 100644
index 00000000..69ff2d42
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPatomicq/CMakeLists.txt
@@ -0,0 +1,34 @@
+file(GLOB SRCS
+    "*.cpp"
+)
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-flto -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_atomic_queue")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+include_directories(./
+        /u/ziyangx/test/atomic_queue/atomic_queue/include)
+
+add_library(${PassName} STATIC ${SRCS})
+target_link_libraries(${PassName} ${Boost_LIBRARIES})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPatomicq/consumer/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPatomicq/consumer/CMakeLists.txt
new file mode 100644
index 00000000..65b55888
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPatomicq/consumer/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required (VERSION 3.6.2 FATAL_ERROR)
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS}
+       /u/ziyangx/test/atomic_queue/atomic_queue/include)
+
+add_executable (consumer consumer.cpp)
+target_link_libraries(consumer LINK_PUBLIC 
+	${Boost_LIBRARIES}
+	rt
+	Threads::Threads
+)
diff --git a/liberty/lib/SLAMP/SLAMPatomicq/consumer/consumer.cpp b/liberty/lib/SLAMP/SLAMPatomicq/consumer/consumer.cpp
new file mode 100644
index 00000000..5cfca3fc
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPatomicq/consumer/consumer.cpp
@@ -0,0 +1,40 @@
+#include <boost/lockfree/spsc_queue.hpp> // ring buffer
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+
+#include "atomic_queue/atomic_queue.h"
+
+namespace bip = boost::interprocess;
+namespace shm
+{
+    using Element = char;
+    Element constexpr NIL = static_cast<Element>(-1);
+    using Queue = atomic_queue::AtomicQueueB<Element, std::allocator<Element>, NIL, false, false, true>;
+}
+
+#include <iostream>
+
+int main()
+{
+    // create segment and corresponding allocator
+    bip::managed_shared_memory segment(bip::open_or_create, "MySharedMemory", 104857600);
+    auto q = static_cast<void *>(segment.find_or_construct<char>("atomic_queue")[65536]());
+    std::cout << q << std::endl;
+
+    shm::Queue *queue = new shm::Queue(65536, q);
+
+    auto counter = 0;
+    // shm::shared_string v(char_alloc);
+    while (true)
+    {
+        if (shm::Element v = queue->pop()) {
+          counter++;
+
+          if (counter % 1000000 == 0) {
+            std::cout << "counter: " << counter << std::endl;
+          }
+        }
+    }
+}
diff --git a/liberty/lib/SLAMP/SLAMPatomicq/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPatomicq/slamp_hooks.h
new file mode 100644
index 00000000..df546117
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPatomicq/slamp_hooks.h
@@ -0,0 +1,371 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/SLAMPboost/BoostSend.cpp b/liberty/lib/SLAMP/SLAMPboost/BoostSend.cpp
new file mode 100644
index 00000000..98395d67
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/BoostSend.cpp
@@ -0,0 +1,539 @@
+#include "slamp_hooks.h"
+#include <boost/lockfree/spsc_queue.hpp> // ring buffer
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+#include <cstdint>
+#include <iostream>
+#include "malloc.h"
+
+// 2MB
+#define LOCAL_BUFFER_SIZE 2097152
+
+namespace bip = boost::interprocess;
+namespace shm
+{
+    // typedef bip::allocator<char, bip::managed_shared_memory::segment_manager> char_alloc;
+    // typedef bip::basic_string<char, std::char_traits<char>, char_alloc >      shared_string;
+
+    // using ring_buffer = boost::lockfree::spsc_queue<shared_string, boost::lockfree::capacity<65536>>;
+    // 4MB
+    using ring_buffer = boost::lockfree::spsc_queue<char, boost::lockfree::capacity<4194304>>;
+}
+
+#include <unistd.h>
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::managed_shared_memory *segment;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+shm::ring_buffer *queue;
+unsigned long counter_load = 0;
+unsigned long counter_store = 0;
+unsigned long counter_ctx = 0;
+unsigned long counter_alloc = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+bool onProfiling = false;
+
+// template <typename T>
+struct LocalBuffer {
+  char buffer[LOCAL_BUFFER_SIZE];
+  shm::ring_buffer *queue;
+  unsigned counter = 0;
+
+  LocalBuffer(shm::ring_buffer *queue) : queue(queue) {}
+
+  template <typename T>
+  LocalBuffer *push(T value) ATTRIBUTE(always_inline) {
+    size_t size = sizeof(T);
+    if (counter + size > LOCAL_BUFFER_SIZE) {
+      flush();
+    }
+    for (unsigned i = 0; i < size; i++) {
+      // lsb first
+      buffer[counter++] = (value >> (i << 3)) & 0xFF;
+    }
+    return this;
+  }
+
+  void flush() {
+    // for (int i = 0; i < counter; i++) {
+    unsigned long pushed = 0;
+    while (pushed < counter) {
+      pushed += queue->push(buffer + pushed, counter - pushed);
+    }
+    // }
+    counter = 0;
+  }
+};
+
+LocalBuffer *local_buffer;
+
+enum DepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    FINISHED
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+  segment = new bip::managed_shared_memory(bip::open_or_create, "MySharedMemory", 65536UL*1600);
+  queue = segment->find_or_construct<shm::ring_buffer>("queue")();
+  local_buffer = new LocalBuffer(queue);
+
+  // send a msg with "fn_id, loop_id"
+  // char msg[100];
+  // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+
+  local_buffer->push(INIT);
+  local_buffer->push(loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  local_buffer->push(pid);
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = nullptr;
+  // __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  local_buffer->push(FINISHED);
+  local_buffer->flush();
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  local_buffer->push(ALLOC)->push(addr)->push(size);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){}
+void SLAMP_exit_fcn(uint32_t id){}
+void SLAMP_enter_loop(uint32_t id){}
+void SLAMP_exit_loop(uint32_t id){}
+void SLAMP_loop_iter_ctx(uint32_t id){}
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  local_buffer->push(LOOP_INVOC);
+
+  counter_ctx++;
+  onProfiling = true;
+}
+void SLAMP_loop_iteration(){
+  local_buffer->push(LOOP_ITER);
+  counter_ctx++;
+}
+
+void SLAMP_loop_exit(){
+  onProfiling = false;
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // send a msg with "load, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  //
+  if (onProfiling) {
+    local_buffer->push(LOAD)->push(instr)->push(addr)->push(bare_instr); //->push(value);
+    counter_load++;
+  }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // send a msg with "store, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  if (onProfiling) {
+    local_buffer->push(STORE)->push(instr)->push(bare_instr)->push(addr);
+    counter_store++;
+  }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  __malloc_hook = old_malloc_hook;
+  void* ptr = malloc(size);
+  local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // printf("malloc %lu at %p\n", size, ptr);
+  counter_alloc++;
+  __malloc_hook = SLAMP_malloc_hook;
+  return ptr;
+}
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  old_free_hook(ptr, caller);
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  old_memalign_hook = __memalign_hook;
+  void* ptr = memalign(alignment, size);
+  local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // printf("memalign %lu at %p\n", size, ptr);
+  counter_alloc++;
+  __memalign_hook = SLAMP_memalign_hook;
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPboost/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPboost/CMakeLists.txt
new file mode 100644
index 00000000..604d7ffd
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/CMakeLists.txt
@@ -0,0 +1,34 @@
+file(GLOB SRCS
+    "*.cpp"
+)
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-flto -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_boost")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+include_directories(./
+        /u/ziyangx/test/boost/boost_1_80_0/install/include)
+
+add_library(${PassName} STATIC ${SRCS})
+target_link_libraries(${PassName} ${Boost_LIBRARIES})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/.gitignore b/liberty/lib/SLAMP/SLAMPboost/consumer/.gitignore
new file mode 100644
index 00000000..378eac25
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPboost/consumer/CMakeLists.txt
new file mode 100644
index 00000000..9ad2d772
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required (VERSION 3.6.2 FATAL_ERROR)
+
+# set(CMAKE_C_COMPILER "clang")
+# set(CMAKE_CXX_COMPILER "clang++")
+# set(CMAKE_LINKER "ld.gold")
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+# set(LINK_FLAGS "${LINK_FLAGS} -flto")
+
+
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable (consumer consumer.cpp ./ProfilingModules/DependenceModule.cpp)
+target_link_libraries(consumer LINK_PUBLIC 
+	${Boost_LIBRARIES}
+	rt
+	Threads::Threads
+)
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.cpp b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.cpp
new file mode 100644
index 00000000..a78b3487
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.cpp
@@ -0,0 +1,118 @@
+#include <cstdint>
+#include <set>
+#include <unordered_set>
+#include <fstream>
+
+#include "slamp_timestamp.h"
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "DependenceModule.h"
+#define SIZE_8M  0x800000
+
+
+static slamp::MemoryMap* smmap = nullptr;
+static std::unordered_set<slamp::KEY, slamp::KEYHash, slamp::KEYEqual> *deplog_set;
+static uint64_t slamp_iteration = 0;
+static uint64_t slamp_invocation = 0;
+static uint32_t target_loop_id = 0;
+
+namespace DepMod {
+// init: setup the shadow memory
+void init(uint32_t loop_id, uint32_t pid) {
+
+  target_loop_id = loop_id;
+  smmap = new slamp::MemoryMap(TIMESTAMP_SIZE_IN_BYTES);
+  deplog_set = new std::unordered_set<slamp::KEY, slamp::KEYHash, slamp::KEYEqual>();
+
+  smmap->init_stack(SIZE_8M, pid);
+  smmap->allocate((void*)&errno, sizeof(errno));
+  smmap->allocate((void*)&stdin, sizeof(stdin));
+  smmap->allocate((void*)&stdout, sizeof(stdout));
+  smmap->allocate((void*)&stderr, sizeof(stderr));
+  smmap->allocate((void*)&sys_nerr, sizeof(sys_nerr));
+
+  {
+    const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+    smmap->allocate((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  }
+  {
+    const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+    smmap->allocate((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  }
+  {
+    const int32_t* itype_ptr = (*__ctype_toupper_loc()) - 128;
+    smmap->allocate((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  }
+}
+
+void fini(const char *filename) {
+  std::ofstream of(filename);
+  of << target_loop_id << " " << 0 << " " << 0 << " "
+       << 0 << " " << 0 << " " << 0 << "\n";
+
+  std::set<slamp::KEY, slamp::KEYComp> ordered(deplog_set->begin(), deplog_set->end());
+  for (auto &k: ordered) {
+    of << target_loop_id << " " << k.src << " " << k.dst << " " << k.dst_bare << " "
+       << (k.cross ? 1 : 0) << " " << 1 << " ";
+    of << "\n";
+  }
+
+  delete smmap;
+  delete deplog_set;
+}
+
+void allocate(void *addr, uint64_t size) {
+  smmap->allocate(addr, size);
+  // std::cout << "allocate " << addr << " " << size << std::endl;
+}
+
+// void log(TS ts, const uint32_t dst_inst, TS *pts, const uint32_t bare_inst,
+         // uint64_t  addr, uint64_t  value, uint8_t  size) {
+void log(TS ts, const uint32_t dst_inst, const uint32_t bare_inst){ 
+
+    uint32_t src_inst = GET_INSTR(ts);
+    uint64_t src_iter = GET_ITER(ts);
+
+    // uint64_t src_invoc = GET_INVOC(ts);
+
+    slamp::KEY key(src_inst, dst_inst, bare_inst, src_iter != slamp_iteration);
+    
+    // std::cout << "src_inst: " << src_inst << " dst_inst: " << dst_inst << " bare_inst: " << bare_inst << " src_iter: " << src_iter << " slamp_iteration: " << slamp_iteration << " src_iter != slamp_iteration: " << (src_iter != slamp_iteration) << std::endl;
+    // deplog_set->insert(key);
+}
+
+// template <unsigned size>
+void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  TS* s = (TS*)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+  TS tss = s[0];
+  if (tss != 0) {
+    log(tss, instr, bare_instr);
+  }
+}
+
+// template <unsigned size>
+void store(uint32_t instr, uint32_t bare_instr, const uint64_t addr) {
+  TS *s = (TS *)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+  // if (!smmap->is_allocated(s)) {
+  //   std::cout << "store not allocated: " << instr << " " << bare_instr << " " << addr << std::endl;
+  // }
+  TS ts = CREATE_TS(instr, slamp_iteration, slamp_invocation);
+
+  // TODO: handle output dependence. ignore it as of now.
+  // if (ASSUME_ONE_ADDR) {
+  s[0] = ts;
+  // } else {
+    // for (auto i = 0; i < size; i++)
+      // s[i] = ts;
+  // }
+}
+
+void loop_invoc() {
+  slamp_iteration = 0;
+  slamp_invocation++;
+}
+
+void loop_iter() {
+  slamp_iteration++;
+}
+} // namespace DepMod
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.h b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.h
new file mode 100644
index 00000000..a2664cdc
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/DependenceModule.h
@@ -0,0 +1,23 @@
+#include <cstdint>
+
+namespace DepMod {
+void init(uint32_t loop_id, uint32_t pid);
+void fini(const char *filename);
+void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value);
+void store(uint32_t instr, uint32_t bare_instr, const uint64_t addr);
+void allocate(void *addr, uint64_t size);
+void loop_invoc();
+void loop_iter();
+
+enum DepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    FINISHED
+};
+
+} // namespace DepMod
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_bound_malloc.h b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_bound_malloc.h
new file mode 100644
index 00000000..0d6b9410
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_bound_malloc.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+#define SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+
+#include <cstddef>
+#include <cstdint>
+namespace slamp 
+{
+
+void init_bound_malloc(void* heap_bound);
+void fini_bound_malloc();
+
+size_t get_object_size(void* ptr);
+
+void* bound_malloc(size_t size, size_t alignment=16);
+bool bound_free(void *ptr, uint64_t &starting_page, unsigned &purge_cnt);
+void* bound_calloc(size_t num, size_t size);
+void* bound_realloc(void* ptr, size_t size);
+void  bound_discard_page();
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_logger.h b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_logger.h
new file mode 100644
index 00000000..89641a03
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_logger.h
@@ -0,0 +1,110 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_LOGGER
+#define SLAMPLIB_HOOKS_SLAMP_LOGGER
+
+#include <cstdint>
+#include <stdint.h>
+#include <stdlib.h>
+#include <functional>
+
+#include "slamp_timestamp.h"
+
+namespace slamp
+{
+
+struct KEY
+{
+  uint32_t src;
+  uint32_t dst;
+  uint32_t dst_bare;
+  uint32_t cross;
+
+  KEY() {}
+  KEY(uint32_t s, uint32_t d, uint32_t b, uint32_t c) : src(s), dst(d), dst_bare(b), cross(c) {}
+};
+
+struct KEYHash
+{
+  size_t operator()(const KEY& key) const
+  {
+    static_assert(sizeof(size_t) == sizeof(uint64_t), "Should be 64bit address");
+    std::hash<uint64_t> hash_fn;
+
+    // hash(32-32) ^ hash(32-1)
+    // FIXME: find a better hash function
+    return hash_fn(((uint64_t)key.src << 32) | key.dst) ^ hash_fn(((uint64_t)key.dst_bare << 1) | (key.cross & 0x1));
+  }
+};
+
+struct KEYComp
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if (src1 < src2)
+      return true;
+    else if (src1 > src2)
+      return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if (dst1 < dst2)
+      return true;
+    else if (dst1 > dst2)
+      return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if (dst_bare1 < dst_bare2)
+      return true;
+    else if (dst_bare1 > dst_bare2)
+      return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    return cross1 < cross2;
+  }
+};
+
+struct KEYEqual
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if ( src1 != src2 ) return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if ( dst1 != dst2 ) return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if ( dst_bare1 != dst_bare2 ) return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    if ( cross1 != cross2 ) return false;
+
+    return true;
+  }
+};
+
+
+void init_logger(uint32_t fn_id, uint32_t loop_id);
+void fini_logger(const char* filename);
+
+uint32_t log(TS ts, const uint32_t dst_instr, TS* pts, const uint32_t bare_inst, uint64_t addr, uint64_t value, uint8_t size);
+void print_log(const char* filename);
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_shadow_mem.h b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_shadow_mem.h
new file mode 100644
index 00000000..ef07201b
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_shadow_mem.h
@@ -0,0 +1,197 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+#define SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+
+#include <cassert>
+#include <csignal>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <set>
+#include <unordered_map>
+
+// higher half of canonical region cannot be used
+
+/// left shift by `shift`, mask 47 LSB, toggle #45 bit?
+#define MASK1 0x00007fffffffffffL
+#define MASK2 0x0000200000000000L
+#define GET_SHADOW(addr, shift)                                                \
+  (((((uint64_t)(addr)) << (shift)) & MASK1) ^ MASK2)
+
+namespace slamp {
+
+class MemoryMap {
+public:
+  uint64_t heapStart = 0;
+  MemoryMap(unsigned r) : ratio(r), ratio_shift(0) {
+    // ratio expected to be a power of 2
+    assert((r & (r - 1)) == 0);
+
+    // log(r)
+    unsigned n = r;
+    while ((n & 1) == 0) {
+      this->ratio_shift += 1;
+      n = n >> 1;
+    }
+
+    // get the page size of the host system
+    pagesize = getpagesize();
+    pagemask = ~(pagesize - 1);
+  }
+
+  ~MemoryMap() {
+    // freeing all remaining shadow addresses
+    for (auto page : pages) {
+      uint64_t s = GET_SHADOW(page, ratio_shift);
+      munmap(reinterpret_cast<void *>(s), pagesize * ratio);
+    }
+  }
+
+  unsigned get_ratio() { return ratio; }
+
+  bool is_allocated(void *addr) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t page = a & pagemask;
+    if (pages.find(page) != pages.end())
+      return true;
+    else
+      return false;
+  }
+
+  /// allocate shadow page if not exist
+  void *allocate(void *addr, size_t size) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t pagebegin = a & pagemask;
+    uint64_t pageend = (a + size - 1) & pagemask;
+
+    // try mmap
+
+    std::set<void *> shadow_pages;
+    bool success = true;
+
+    for (uint64_t page = pagebegin; page <= pageend; page += pagesize) {
+      if (pages.find(page) != pages.end())
+        continue;
+
+      uint64_t s = GET_SHADOW(page, ratio_shift);
+      // create a shadow page for the page
+      void *p = mmap(reinterpret_cast<void *>(s), pagesize * ratio,
+                     PROT_WRITE | PROT_READ,
+                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+      if (p == MAP_FAILED) {
+        int err = errno;
+        printf("mmap failed: %lx errno: %d\n", s, err);
+        raise(SIGINT);
+
+        success = false;
+        break;
+      } else {
+        shadow_pages.insert(p);
+      }
+    }
+
+    if (success) {
+      for (uint64_t page = pagebegin; page <= pageend; page += pagesize)
+        pages.insert(page);
+      uint64_t pagebegin = a & pagemask;
+      uint64_t pageend = (a + size - 1) & pagemask;
+
+      // return shadow_mem
+      auto *shadow_addr = (uint64_t *)GET_SHADOW(a, ratio_shift);
+      return (void *)(shadow_addr);
+    } else {
+      // cleanup
+      for (auto shadow_page : shadow_pages)
+        munmap(shadow_page, pagesize * ratio);
+      return nullptr;
+    }
+  }
+
+  // free the shadow pages
+  void deallocate_pages(uint64_t page, unsigned cnt) {
+    munmap(reinterpret_cast<void *>(GET_SHADOW(page, ratio_shift)),
+           pagesize * ratio * cnt);
+
+    // fprintf(stderr, "deallocate_pages: %lx %d\n", GET_SHADOW(page, ratio_shift), cnt);
+
+    for (auto i = 0; i < cnt; i++, page += pagesize)
+      pages.erase(page);
+  }
+
+  /// for realloc; the dependence carries over
+  void copy(void *dst, void *src, size_t size) {
+    size_t shadow_size = size * ratio;
+    void *shadow_dst = (void *)GET_SHADOW(dst, ratio_shift);
+    void *shadow_src = (void *)GET_SHADOW(src, ratio_shift);
+    memcpy(shadow_dst, shadow_src, shadow_size);
+  }
+
+  void init_heap(void *addr) {
+    heapStart = reinterpret_cast<uint64_t>(addr);
+  }
+
+  // init stack size to be fixed 8MB
+  // the stack in /proc/$pid/maps changes in runtime, use it to find the end
+  void init_stack(uint64_t stack_size, uint64_t pid) {
+    char filename[256];
+    char buf[5000];
+    sprintf(filename, "/proc/%lu/maps", pid);
+    // sprintf(filename, "/proc/%u/maps", getpid());
+
+    FILE *fp = fopen(filename, "r");
+    if (!fp) {
+      perror(filename);
+      exit(EXIT_FAILURE);
+    }
+
+    bool allocated = false;
+
+    while (fgets(buf, sizeof(buf), fp) != nullptr) {
+      uint64_t start, end;
+      char name[5000];
+
+      int n = sscanf(buf, "%lx-%lx %*c%*c%*c%*c %*llx %*x:%*x %*lu %s", &start,
+                     &end, name);
+
+      if (n != 3) {
+        continue;
+      }
+
+      // FIXME: get heap start addr
+      if (!strcmp(name, "[heap]")) {
+        heapStart = start;
+      }
+
+
+      if (!strcmp(name, "[stack]")) {
+        // stack grow from end (big address) backwards
+        // print the stack start and end
+        printf("stack: %lx %lx\n", end - stack_size, end);
+        allocate(reinterpret_cast<void *>(end - stack_size), stack_size);
+        allocated = true;
+        break;
+      }
+    }
+
+    if (!allocated) {
+      fprintf(stderr, "Error: failed to allocate shadow for stack");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+private:
+  std::set<uint64_t> pages; // page table
+
+  unsigned ratio; // (size of metadata) / (size of real data)
+  unsigned ratio_shift;
+  uint64_t pagesize;
+  uint64_t pagemask;
+};
+
+} // namespace slamp
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_timestamp.h b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_timestamp.h
new file mode 100644
index 00000000..fc9c1428
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/ProfilingModules/slamp_timestamp.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+#define SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+
+#include <stdint.h>
+
+typedef uint64_t TS; // first 20 bits for instr and following 44 bits for iter
+#define TIMESTAMP_SIZE_IN_BYTES 8
+#define TIMESTAMP_SIZE_IN_POWER_OF_TWO 3
+#define ITERATION_SIZE 40
+#define INVOCATION_SIZE 4 // 44-40
+#define CREATE_TS(instr, iter, invoc) ( ((TS)instr << 44) | (((TS)iter & (TS)0xffffffffff) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xf))
+#define CREATE_TS_HASH(instr, hash, iter, invoc)                               \
+  (((TS)instr << 44) |                                                         \
+   (((TS)hash & (TS)0xfffffffff) << (INVOCATION_SIZE + 4)) |                   \
+   (((TS)iter & (TS)0xf) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xf))
+#define GET_INSTR(ts) ((ts >> 44) & 0xfffff)
+#define GET_HASH(ts) ( (ts >> 8) & 0xfffffffff)
+#define GET_ITER(ts) ( (ts >> INVOCATION_SIZE) & 0xffffffffff)
+#define GET_INVOC(ts) ( ts & 0xf)
+
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPboost/consumer/consumer.cpp b/liberty/lib/SLAMP/SLAMPboost/consumer/consumer.cpp
new file mode 100644
index 00000000..c86dc291
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/consumer/consumer.cpp
@@ -0,0 +1,200 @@
+#include <boost/lockfree/spsc_queue.hpp> // ring buffer
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+#include <cstdint>
+#include "ProfilingModules/DependenceModule.h"
+#include <iostream>
+#include <sstream>
+
+#define DEBUG 0
+#define ACTION 0
+
+
+namespace bip = boost::interprocess;
+namespace shm
+{
+    // typedef bip::allocator<char, bip::managed_shared_memory::segment_manager> char_alloc;
+    // typedef bip::basic_string<char, std::char_traits<char>, char_alloc >      shared_string;
+
+    // shared_string, 
+    using ring_buffer = boost::lockfree::spsc_queue<char, boost::lockfree::capacity<4194304>>;
+}
+
+
+// 2MB
+#define LOCAL_BUFFER_SIZE 4194304
+
+struct LocalReceiveBuffer {
+  shm::ring_buffer *queue;
+
+  char buffer[LOCAL_BUFFER_SIZE];
+  unsigned counter = 0;
+  unsigned buffer_size = 0;
+
+  LocalReceiveBuffer(shm::ring_buffer *queue) : queue(queue) {}
+
+  template <typename T>
+  void pop(T &t) {
+    size_t size = sizeof(T);
+    T value = 0;
+    uint8_t current_byte = 0;
+
+    while (current_byte < size) {
+      // load the value from the buffer
+      while (counter < buffer_size && current_byte < size) {
+        // lsb first
+        // auto v = (uint64_t)(uint8_t)buffer[counter];
+        // value |= (v << (8 * current_byte));
+        counter++;
+        current_byte++;
+      }
+
+      // load the buffer up
+      if (counter == buffer_size) {
+        buffer_size = queue->pop(buffer, LOCAL_BUFFER_SIZE);
+        counter = 0;
+      }
+    }
+
+    // std::cout << "pop " << (uint64_t)value << std::endl;
+
+    // set the value
+    t = value;
+  }
+};
+
+
+int main()
+{
+    // create segment and corresponding allocator
+    bip::managed_shared_memory segment(bip::open_or_create, "MySharedMemory", 104857600);
+    // shm::char_alloc char_alloc(segment.get_segment_manager());
+
+    shm::ring_buffer *queue = segment.find_or_construct<shm::ring_buffer>("queue")();
+    LocalReceiveBuffer buffer(queue);
+
+    uint64_t counter = 0;
+    // shm::shared_string v(char_alloc);
+
+    using Action=DepMod::DepModAction;
+
+    uint32_t loop_id;
+    // while (true) {
+    while (false) {
+      char v;
+      buffer.pop(v);
+      counter++;
+
+      switch (v) {
+      case Action::INIT: {
+        uint32_t pid;
+        buffer.pop(loop_id);
+        buffer.pop(pid);
+
+        if (DEBUG) {
+          std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+        }
+#if ACTION
+        DepMod::init(loop_id, pid);
+#endif
+        break;
+      };
+      case Action::LOAD: {
+        uint32_t instr;
+        uint64_t addr;
+        uint32_t bare_instr;
+        uint64_t value = 0;
+        buffer.pop(instr);
+        buffer.pop(addr);
+        buffer.pop(bare_instr);
+        // buffer.pop(value);
+        if (DEBUG) {
+          std::cout << "LOAD: " << instr << " " << addr << " " << bare_instr << " " << value << std::endl;
+        }
+#if ACTION
+        DepMod::load(instr, addr, bare_instr, value);
+        // DepMod::load(instr, addr, bare_instr, value);
+#endif
+
+        break;
+      };
+      case Action::STORE: {
+        uint32_t instr;
+        uint32_t bare_instr;
+        uint64_t addr;
+        buffer.pop(instr);
+        buffer.pop(bare_instr);
+        buffer.pop(addr);
+        if (DEBUG) {
+          std::cout << "STORE: " << instr << " " << bare_instr << " " << addr << std::endl;
+        }
+#if ACTION
+        DepMod::store(instr, bare_instr, addr);
+#endif
+        break;
+      };
+      case Action::ALLOC: {
+        uint64_t addr;
+        uint64_t size;
+        buffer.pop(addr);
+        buffer.pop(size);
+        if (DEBUG) {
+          std::cout << "ALLOC: " << addr << " " << size << std::endl;
+        }
+#if ACTION
+        DepMod::allocate(reinterpret_cast<void *>(addr), size);
+#endif
+        break;
+      };
+      case Action::LOOP_INVOC: {
+#if ACTION
+        DepMod::loop_invoc();
+#endif
+
+        if (DEBUG) {
+          std::cout << "LOOP_INVOC" << std::endl;
+        }
+        break;
+      };
+      case Action::LOOP_ITER: {
+#if ACTION
+        DepMod::loop_iter();
+#endif
+
+        if (DEBUG) {
+          std::cout << "LOOP_ITER" << std::endl;
+        }
+        break;
+      };
+      case Action::FINISHED: {
+        std::stringstream ss;
+        ss << "deplog-" << loop_id << ".txt";
+#if ACTION
+        DepMod::fini(ss.str().c_str());
+#endif
+        std::cout << "Finished loop: " << loop_id << " after " << counter
+                  << " events" << std::endl;
+        break;
+      };
+      default:
+        std::cout << "Unknown action: " << v << std::endl;
+        exit(-1);
+      }
+
+      if (counter % 100000000 == 0) {
+        std::cout << "Processed " << counter / 1000000 << "M events" << std::endl;
+      }
+    }
+
+    while (true) {
+      char v;
+      while (!queue->pop(v));
+      counter++;
+
+      if (counter % 100000000 == 0) {
+        std::cout << "Processed " << counter / 1000000 << "M events" << std::endl;
+      }
+    }
+}
diff --git a/liberty/lib/SLAMP/SLAMPboost/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPboost/slamp_hooks.h
new file mode 100644
index 00000000..df546117
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPboost/slamp_hooks.h
@@ -0,0 +1,371 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPcustom/CMakeLists.txt
new file mode 100644
index 00000000..f270e779
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CMakeLists.txt
@@ -0,0 +1,41 @@
+file(GLOB SRCS
+    # "CustomSend_all.cpp"
+    # "CustomSend_ol.cpp"
+    # "CustomSend_lv.cpp"
+    # "CustomSend_pt.cpp"
+    "CustomSend.cpp"
+    # "*.c"
+)
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+# set C++ flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -g")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-flto -Wno-inline -O3 -g -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_custom")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+include_directories(./
+        /u/ziyangx/test/boost/boost_1_80_0/install/include)
+
+add_library(${PassName} STATIC ${SRCS})
+target_link_libraries(${PassName} ${Boost_LIBRARIES})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CustomSend.cpp b/liberty/lib/SLAMP/SLAMPcustom/CustomSend.cpp
new file mode 100644
index 00000000..40ea862a
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CustomSend.cpp
@@ -0,0 +1,812 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <emmintrin.h>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include <xmmintrin.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#define TRACK_CONTEXT
+
+#define MM_STREAM
+//#define SAMPLING_ITER
+
+namespace bip = boost::interprocess;
+
+static constexpr uint64_t QSIZE_GUARD = QSIZE - 60;
+
+// static unsigned long counter_load = 0;
+// static unsigned long counter_store = 0;
+// static unsigned long counter_ctx = 0;
+// static unsigned long counter_alloc = 0;
+// static unsigned long counter_invoc = 0;
+// static unsigned long counter_iter = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+static bool on_profiling = false;
+
+static unsigned int context = 0;
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static Queue_p dqA, dqB, dq, dq_other;
+static uint64_t dq_index = 0;
+static uint32_t *dq_data;
+// static uint64_t total_pushed = 0;
+static uint64_t total_swapped = 0;
+static void swap(){
+  if(dq == dqA){
+    dq = dqB;
+    dq_other = dqA;
+  }else{
+    dq = dqA;
+    dq_other = dqB;
+  }
+  dq_data = dq->data;
+}
+
+static void produce_wait() ATTRIBUTE(noinline){
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+  dq->ready_to_write = false;
+  while (!dq_other->ready_to_write){
+    // spin
+    usleep(10);
+  }
+  swap();
+  dq->ready_to_read = false;
+  dq_index = 0;
+  total_swapped++;
+}
+
+// the packet is always 128bit, pad  with 0
+static void produce_32(uint32_t x) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, 0, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+#else
+  dq_data[dq_index] = x;
+  // dq_data[dq_index + 1] = 0;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32(uint32_t x, uint32_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index + 1] = y;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_64_64(const uint64_t x, const uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi64x(y, x));
+  // _mm_stream_si64((long long *) &dq_data[dq_index], x);
+  // _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  *((uint64_t *) &dq_data[dq_index]) = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+// static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) {
+static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  // FIXME: set 32bit x, 32bit y, 64bit z, small endian
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], z);
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32( z >> 32, z & 0xFFFFFFFF, y, x));
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  *(uint64_t*)&dq_data[dq_index+2] = z;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_32(uint32_t x, uint32_t y, uint32_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, z, y, x));
+
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_si32((int *) &dq_data[dq_index+1], y);
+  // _mm_stream_si32((int *) &dq_data[dq_index+2], z);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  dq_data[dq_index+2] = z;
+  dq_data[dq_index+3] = 0;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+// static void produce_32_64_64(uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline) {
+// #ifdef MM_STREAM
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+1], (__m64)y);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+3], (__m64)z);
+// #else
+  // dq_data[dq_index] = x;
+  // *(uint64_t*)&dq_data[dq_index+1] = y;
+  // *(uint64_t*)&dq_data[dq_index+3] = z;
+// #endif
+  // dq_index += 5;
+  // if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    // produce_wait();
+  // }
+// }
+
+
+// #define CONSUME         sq_consume(the_queue);
+// #define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+#define PRODUCE(x)      produce_32((uint32_t)x);
+
+#define COMBINE_2_32(x,y)   ((((uint64_t)y)<<32) | (uint32_t)(x)) 
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook;
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+
+enum DepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    LOOP_EXIT,
+    FINISHED,
+    FUNC_ENTRY,
+    FUNC_EXIT,
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+  uint32_t pid = getpid();
+
+  // get QUEUE ID from env
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cerr << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+  
+  dqA = segment->find<Queue>("DQ_A").first;
+  dqB = segment->find<Queue>("DQ_B").first;
+  dq = dqA;
+  dq_other = dqB;
+  dq_index = 0;
+  dq_data = dq->data;
+
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // if (the_queue == nullptr) {
+    // std::cout << "Error: could not create queue" << std::endl;
+    // exit(-1);
+  // }
+  // the_queue->data = data;
+  // if (the_queue->data == nullptr) {
+    // std::cout << "Error: could not create queue data" << std::endl;
+    // exit(-1);
+  // }
+
+  // [> Initialize the queue data structure <]
+  // the_queue->p_data = (uint64_t) the_queue->data;
+  // the_queue->c_inx = 0;
+  // the_queue->c_margin = 0;
+  // the_queue->p_glb_inx = 0;
+  // the_queue->c_glb_inx = 0;
+  // the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  // the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // // local_buffer = new LocalBuffer(queue);
+
+  // // send a msg with "fn_id, loop_id"
+  // // char msg[100];
+  // // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  produce_32_32_32(INIT, loop_id, pid);
+
+  auto allocateLibcReqs = [](void *addr, size_t size) {
+    produce_32_32_64(ALLOC, size, (uint64_t)addr);
+  };
+
+  allocateLibcReqs((void*)&errno, sizeof(errno));
+  allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+  // // FIXME: a dirty way to get xalancbmk to work
+  // auto locale = localeconv();
+  // auto decimal = locale->decimal_point;
+  // allocateLibcReqs((void*)locale, sizeof(*locale));
+  // allocateLibcReqs((void*)decimal, sizeof(*decimal));
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = SLAMP_realloc_hook;
+  // __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+
+  // flush
+  // produce_wait();
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  // std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE(FINISHED);
+  // sq_flushQueue(the_queue);
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+
+  if (nested_level != 0) {
+    std::cerr << "Error: nested_level != 0 on exit" << std::endl;
+    exit(-1);
+  }
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  // local_buffer->push(ALLOC)->push(addr)->push(size);
+
+  produce_32_32_64(ALLOC, size, addr);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){}
+void SLAMP_exit_fcn(uint32_t id){}
+void SLAMP_enter_loop(uint32_t id){}
+void SLAMP_exit_loop(uint32_t id){}
+void SLAMP_loop_iter_ctx(uint32_t id){}
+
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  // local_buffer->push(LOOP_INVOC);
+  PRODUCE(LOOP_INVOC);
+
+  // counter_ctx++;
+
+  nested_level++;
+  on_profiling = true;
+
+  // if (counter_invoc % 1 == 0) {
+    // on_profiling= true;
+  // }
+  // counter_invoc++;
+}
+
+void SLAMP_loop_iteration(){
+  // local_buffer->push(LOOP_ITER);
+  PRODUCE(LOOP_ITER);
+  // counter_ctx++;
+
+#ifdef SAMPLING_ITER
+    if (counter_iter % 100 == 0) {
+      on_profiling = true;
+    }
+    if (counter_iter % 100 == 10) { // 0-10000 out of 100000, sampling 10%
+      on_profiling = false;
+    }
+    counter_iter++;
+#endif
+}
+
+void SLAMP_loop_exit(){
+  nested_level--;
+  PRODUCE(LOOP_EXIT);
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){
+#ifdef TRACK_CONTEXT
+  if (nested_level == 1) {
+    context = instr;
+    produce_32_32(FUNC_ENTRY, instr);
+  }
+#endif
+}
+void SLAMP_pop(){
+#ifdef TRACK_CONTEXT
+  if (nested_level == 1) {
+    produce_32_32(FUNC_EXIT, context);
+    context = 0;
+  }
+#endif
+}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // send a msg with "load, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  //
+  if (on_profiling) {
+    produce_32_32_64(LOAD, instr, addr);
+    // counter_load++;
+  }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // send a msg with "store, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  if (on_profiling) {
+    // produce_3(STORE, COMBINE_2_32(instr, bare_instr), addr);
+    // produce_64_64(COMBINE_2_32(STORE, instr), addr);
+    produce_32_32_64(STORE, instr, addr);
+    // counter_store++;
+  }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = malloc(size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  //
+  produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+  // printf("malloc %lu at %p\n", size, ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* new_ptr = realloc(ptr, size);
+  // local_buffer->push(REALLOC)->push((uint64_t)ptr)->push((uint64_t)new_ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)new_ptr, size);
+  produce_32_32_64(ALLOC, size, (uint64_t)new_ptr);
+  // printf("realloc %p to %lu at %p", ptr, size, new_ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return new_ptr;
+}
+
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  old_free_hook(ptr, caller);
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = memalign(alignment, size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)ptr, size);
+  produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+
+  // printf("memalign %lu at %p\n", size, ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CustomSend_all.cpp b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_all.cpp
new file mode 100644
index 00000000..82494607
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_all.cpp
@@ -0,0 +1,894 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <emmintrin.h>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include <xmmintrin.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#define MM_STREAM
+//#define SAMPLING_ITER
+
+namespace bip = boost::interprocess;
+
+static constexpr uint64_t QSIZE_GUARD = QSIZE - 60;
+
+// static unsigned long counter_load = 0;
+// static unsigned long counter_store = 0;
+// static unsigned long counter_ctx = 0;
+// static unsigned long counter_alloc = 0;
+// static unsigned long counter_invoc = 0;
+// static unsigned long counter_iter = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+static bool on_profiling = false;
+
+static uint32_t ext_fn_inst_id = 0;
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static Queue_p dqA, dqB, dq, dq_other;
+static uint64_t dq_index = 0;
+static uint32_t *dq_data;
+// static uint64_t total_pushed = 0;
+static uint64_t total_swapped = 0;
+static void swap(){
+  if(dq == dqA){
+    dq = dqB;
+    dq_other = dqA;
+  }else{
+    dq = dqA;
+    dq_other = dqB;
+  }
+  dq_data = dq->data;
+}
+
+static void produce_wait() ATTRIBUTE(noinline){
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+  dq->ready_to_write = false;
+  while (!dq_other->ready_to_write){
+    // spin
+    usleep(10);
+  }
+  swap();
+  dq->ready_to_read = false;
+  dq_index = 0;
+  total_swapped++;
+}
+
+// the packet is always 128bit, pad  with 0
+static void produce_32(uint32_t x) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, 0, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+#else
+  dq_data[dq_index] = x;
+  // dq_data[dq_index + 1] = 0;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32(uint32_t x, uint32_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index + 1] = y;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_64(uint32_t x, uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  dq_data[dq_index] = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_64_64(uint32_t w, uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], w);
+  _mm_stream_si32((int *) &dq_data[dq_index+1], x);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 6], z);
+#else
+  dq_data[dq_index] = w;
+  dq_data[dq_index+1] = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+  dq_data[dq_index + 6] = z;
+#endif
+  dq_index += 8;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_8_24_32_64(uint8_t x, uint32_t y, uint32_t z, uint64_t w) ATTRIBUTE(noinline){
+  uint32_t xy = (y << 8) | x;
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(z, w, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], xy);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], z);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], w);
+#else
+  dq_data[dq_index] = xy;
+  dq_data[dq_index + 1] = z;
+  *((uint64_t *) &dq_data[dq_index + 2]) = w;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+static void produce_64_64(const uint64_t x, const uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi64x(y, x));
+  // _mm_stream_si64((long long *) &dq_data[dq_index], x);
+  // _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  *((uint64_t *) &dq_data[dq_index]) = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+// static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) {
+static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], z);
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32( z >> 32, z & 0xFFFFFFFF, y, x));
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  *(uint64_t*)&dq_data[dq_index+2] = z;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_32(uint32_t x, uint32_t y, uint32_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, z, y, x));
+
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_si32((int *) &dq_data[dq_index+1], y);
+  // _mm_stream_si32((int *) &dq_data[dq_index+2], z);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  dq_data[dq_index+2] = z;
+  dq_data[dq_index+3] = 0;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+// static void produce_32_64_64(uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline) {
+// #ifdef MM_STREAM
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+1], (__m64)y);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+3], (__m64)z);
+// #else
+  // dq_data[dq_index] = x;
+  // *(uint64_t*)&dq_data[dq_index+1] = y;
+  // *(uint64_t*)&dq_data[dq_index+3] = z;
+// #endif
+  // dq_index += 5;
+  // if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    // produce_wait();
+  // }
+// }
+
+
+// #define CONSUME         sq_consume(the_queue);
+// #define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+#define PRODUCE(x)      produce_32((uint32_t)x);
+
+#define COMBINE_2_32(x,y)   ((((uint64_t)y)<<32) | (uint32_t)(x)) 
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook; \
+  __free_hook = SLAMP_free_hook;
+
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook; \
+  __free_hook = old_free_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+
+// enum DepModAction: char
+// {
+//     INIT = 0,
+//     LOAD,
+//     STORE,
+//     ALLOC,
+//     LOOP_INVOC,
+//     LOOP_ITER,
+//     FINISHED
+// };
+enum UnifiedAction : char {
+  INIT = 0,
+  LOAD,
+  STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_ENTRY,
+  LOOP_EXIT,
+  LOOP_ITER_CTX,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  POINTS_TO_INST,
+  POINTS_TO_ARG,
+  FINISHED
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+
+  // get QUEUE ID from env
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cerr << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+  
+  dqA = segment->find<Queue>("DQ_A").first;
+  dqB = segment->find<Queue>("DQ_B").first;
+  dq = dqA;
+  dq_other = dqB;
+  dq_index = 0;
+  dq_data = dq->data;
+
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // if (the_queue == nullptr) {
+    // std::cout << "Error: could not create queue" << std::endl;
+    // exit(-1);
+  // }
+  // the_queue->data = data;
+  // if (the_queue->data == nullptr) {
+    // std::cout << "Error: could not create queue data" << std::endl;
+    // exit(-1);
+  // }
+
+  // [> Initialize the queue data structure <]
+  // the_queue->p_data = (uint64_t) the_queue->data;
+  // the_queue->c_inx = 0;
+  // the_queue->c_margin = 0;
+  // the_queue->p_glb_inx = 0;
+  // the_queue->c_glb_inx = 0;
+  // the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  // the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // // local_buffer = new LocalBuffer(queue);
+
+  // // send a msg with "fn_id, loop_id"
+  // // char msg[100];
+  // // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  produce_32_32_32(INIT, loop_id, pid);
+
+  auto allocateLibcReqs = [](void *addr, size_t size) {
+    produce_8_24_32_64(ALLOC, 0, size, (uint64_t)addr);
+    // produce_32_32_64(ALLOC, size, (uint64_t)addr);
+  };
+
+  allocateLibcReqs((void*)&errno, sizeof(errno));
+  allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = SLAMP_realloc_hook;
+  __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+  // flush
+  produce_wait();
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  // std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE(FINISHED);
+  // sq_flushQueue(the_queue);
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+
+  if (nested_level != 0) {
+    std::cerr << "Error: nested_level != 0 on exit" << std::endl;
+    exit(-1);
+  }
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  // local_buffer->push(ALLOC)->push(addr)->push(size);
+
+  produce_32_32_64(ALLOC, size, addr);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){
+  produce_32_32(FUNC_ENTRY, id);
+}
+
+void SLAMP_exit_fcn(uint32_t id){
+  produce_32_32(FUNC_EXIT, id);
+}
+
+void SLAMP_enter_loop(uint32_t id){
+  produce_32_32(LOOP_ENTRY, id);
+}
+
+void SLAMP_exit_loop(uint32_t id){
+  produce_32_32(LOOP_EXIT, id);
+}
+
+void SLAMP_loop_iter_ctx(uint32_t id){
+  // produce_32_32(LOOP_ITER_CTX, id);
+}
+
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  // local_buffer->push(LOOP_INVOC);
+  PRODUCE(LOOP_INVOC);
+
+  // counter_ctx++;
+
+  nested_level++;
+  on_profiling = true;
+
+  // if (counter_invoc % 1 == 0) {
+    // on_profiling= true;
+  // }
+  // counter_invoc++;
+}
+
+void SLAMP_loop_iteration(){
+  // local_buffer->push(LOOP_ITER);
+  PRODUCE(LOOP_ITER);
+  // counter_ctx++;
+
+#ifdef SAMPLING_ITER
+    if (counter_iter % 100 == 0) {
+      on_profiling = true;
+    }
+    if (counter_iter % 100 == 10) { // 0-10000 out of 100000, sampling 10%
+      on_profiling = false;
+    }
+    counter_iter++;
+#endif
+}
+
+void SLAMP_loop_exit(){
+  nested_level--;
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t fcnId, uint32_t argId, void *ptr){
+  // FIXME: combine fcnid and argid to 32 bit
+  uint32_t id = (fcnId << 16) | (argId & 0xffff);
+
+  produce_32_32_64(POINTS_TO_ARG, id, (uint64_t)ptr);
+}
+void SLAMP_report_base_pointer_inst(uint32_t instId, void *ptr){
+  produce_32_32_64(POINTS_TO_INST, instId, (uint64_t)ptr);
+}
+
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){
+  ext_fn_inst_id = instr;
+}
+void SLAMP_ext_pop(){
+  ext_fn_inst_id = 0;
+}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // // send a msg with "load, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // //
+  if (on_profiling) {
+    produce_32_32_64_64(LOAD, instr, addr, value);
+    // counter_load++;
+  }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // // send a msg with "store, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  if (on_profiling) {
+    // produce_3(STORE, COMBINE_2_32(instr, bare_instr), addr);
+    // produce_64_64(COMBINE_2_32(STORE, instr), addr);
+    produce_32_32_64(STORE, instr, addr);
+    // counter_store++;
+  }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = malloc(size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  //
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+  // printf("malloc %lu at %p\n", size, ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* new_ptr = realloc(ptr, size);
+  // local_buffer->push(REALLOC)->push((uint64_t)ptr)->push((uint64_t)new_ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)new_ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)new_ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)new_ptr);
+  // printf("realloc %p to %lu at %p", ptr, size, new_ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return new_ptr;
+}
+
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  TURN_OFF_HOOKS
+  free(ptr);
+  produce_32_64(FREE, (uint64_t)ptr);
+  TURN_ON_HOOKS
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = memalign(alignment, size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+
+  // printf("memalign %lu at %p\n", size, ptr);
+  // counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CustomSend_lv.cpp b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_lv.cpp
new file mode 100644
index 00000000..ead7b414
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_lv.cpp
@@ -0,0 +1,675 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <emmintrin.h>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include <xmmintrin.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#define MM_STREAM
+//#define SAMPLING_ITER
+
+namespace bip = boost::interprocess;
+
+static constexpr uint64_t QSIZE_GUARD = QSIZE - 60;
+
+static unsigned long counter_load = 0;
+static unsigned long counter_store = 0;
+static unsigned long counter_ctx = 0;
+static unsigned long counter_alloc = 0;
+static unsigned long counter_invoc = 0;
+static unsigned long counter_iter = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static Queue_p dqA, dqB, dq, dq_other;
+static uint64_t dq_index = 0;
+static uint32_t *dq_data;
+// static uint64_t total_pushed = 0;
+static uint64_t total_swapped = 0;
+static void swap(){
+  if(dq == dqA){
+    dq = dqB;
+    dq_other = dqA;
+  }else{
+    dq = dqA;
+    dq_other = dqB;
+  }
+  dq_data = dq->data;
+}
+
+static void produce_wait() ATTRIBUTE(noinline){
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+  dq->ready_to_write = false;
+  while (!dq_other->ready_to_write){
+    // spin
+    usleep(10);
+  }
+  swap();
+  dq->ready_to_read = false;
+  dq_index = 0;
+  total_swapped++;
+}
+
+// the packet is always 128bit, pad  with 0
+static void produce_32(uint32_t x) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, 0, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+#else
+  dq_data[dq_index] = x;
+  // dq_data[dq_index + 1] = 0;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_64_64(const uint64_t x, const uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi64x(y, x));
+  // _mm_stream_si64((long long *) &dq_data[dq_index], x);
+  // _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  *((uint64_t *) &dq_data[dq_index]) = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+// static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) {
+static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  // FIXME: set 32bit x, 32bit y, 64bit z, small endian
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], z);
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32( z >> 32, z & 0xFFFFFFFF, y, x));
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  *(uint64_t*)&dq_data[dq_index+2] = z;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_32(uint32_t x, uint32_t y, uint32_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, z, y, x));
+
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_si32((int *) &dq_data[dq_index+1], y);
+  // _mm_stream_si32((int *) &dq_data[dq_index+2], z);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  dq_data[dq_index+2] = z;
+  dq_data[dq_index+3] = 0;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+// static void produce_32_64_64(uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline) {
+// #ifdef MM_STREAM
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+1], (__m64)y);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+3], (__m64)z);
+// #else
+  // dq_data[dq_index] = x;
+  // *(uint64_t*)&dq_data[dq_index+1] = y;
+  // *(uint64_t*)&dq_data[dq_index+3] = z;
+// #endif
+  // dq_index += 5;
+  // if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    // produce_wait();
+  // }
+// }
+
+
+// #define CONSUME         sq_consume(the_queue);
+// #define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+#define PRODUCE(x)      produce_32((uint32_t)x);
+
+#define COMBINE_2_32(x,y)   ((((uint64_t)y)<<32) | (uint32_t)(x)) 
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook;
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+
+enum LoadeValueModAction: char
+{
+    INIT = 0,
+    LOAD,
+    FINISHED
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+
+  // get QUEUE ID from env
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cerr << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+  
+  dqA = segment->find<Queue>("DQ_A").first;
+  dqB = segment->find<Queue>("DQ_B").first;
+  dq = dqA;
+  dq_other = dqB;
+  dq_index = 0;
+  dq_data = dq->data;
+
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // if (the_queue == nullptr) {
+    // std::cout << "Error: could not create queue" << std::endl;
+    // exit(-1);
+  // }
+  // the_queue->data = data;
+  // if (the_queue->data == nullptr) {
+    // std::cout << "Error: could not create queue data" << std::endl;
+    // exit(-1);
+  // }
+
+  // [> Initialize the queue data structure <]
+  // the_queue->p_data = (uint64_t) the_queue->data;
+  // the_queue->c_inx = 0;
+  // the_queue->c_margin = 0;
+  // the_queue->p_glb_inx = 0;
+  // the_queue->c_glb_inx = 0;
+  // the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  // the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // // local_buffer = new LocalBuffer(queue);
+
+  // // send a msg with "fn_id, loop_id"
+  // // char msg[100];
+  // // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  produce_32_32_32(INIT, loop_id, pid);
+
+  // auto allocateLibcReqs = [](void *addr, size_t size) {
+  //   produce_32_32_64(ALLOC, size, (uint64_t)addr);
+  // };
+
+  // allocateLibcReqs((void*)&errno, sizeof(errno));
+  // allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  // allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  // allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  // allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+  // // FIXME: a dirty way to get xalancbmk to work
+  // auto locale = localeconv();
+  // auto decimal = locale->decimal_point;
+  // allocateLibcReqs((void*)locale, sizeof(*locale));
+  // allocateLibcReqs((void*)decimal, sizeof(*decimal));
+
+  // old_malloc_hook = __malloc_hook;
+  // // old_free_hook = __free_hook;
+  // old_memalign_hook = __memalign_hook;
+  // old_realloc_hook = __realloc_hook;
+  // __malloc_hook = SLAMP_malloc_hook;
+  // __free_hook = nullptr;
+  // __realloc_hook = SLAMP_realloc_hook;
+  // // __free_hook = SLAMP_free_hook;
+  // __memalign_hook = SLAMP_memalign_hook;
+
+  // flush
+  produce_wait();
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE(FINISHED);
+  // sq_flushQueue(the_queue);
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+
+  if (nested_level != 0) {
+    std::cerr << "Error: nested_level != 0 on exit" << std::endl;
+    exit(-1);
+  }
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){}
+void SLAMP_exit_fcn(uint32_t id){}
+void SLAMP_enter_loop(uint32_t id){}
+void SLAMP_exit_loop(uint32_t id){}
+void SLAMP_loop_iter_ctx(uint32_t id){}
+
+void SLAMP_loop_invocation(){}
+
+void SLAMP_loop_iteration(){}
+void SLAMP_loop_exit(){}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value, uint32_t size) ATTRIBUTE(always_inline) {
+  // send a msg with "load, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  //
+    produce_32_32_64(LOAD, instr, value);
+    // produce_32_32_64(LOAD, instr, addr);
+    // produce_32_32_64(LOAD, size, value);
+    counter_load++;
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value, 1);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value, 2);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value, 4);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value, 8);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0, n);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  // SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  // SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  // SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  // SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  // SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CustomSend_ol.cpp b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_ol.cpp
new file mode 100644
index 00000000..7438741b
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_ol.cpp
@@ -0,0 +1,862 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <emmintrin.h>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include <xmmintrin.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#define MM_STREAM
+//#define SAMPLING_ITER
+
+namespace bip = boost::interprocess;
+
+static constexpr uint64_t QSIZE_GUARD = QSIZE - 60;
+
+static unsigned long counter_load = 0;
+static unsigned long counter_store = 0;
+static unsigned long counter_ctx = 0;
+static unsigned long counter_alloc = 0;
+static unsigned long counter_invoc = 0;
+static unsigned long counter_iter = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+static bool on_profiling = false;
+
+static uint32_t ext_fn_inst_id = 0;
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static Queue_p dqA, dqB, dq, dq_other;
+static uint64_t dq_index = 0;
+static uint32_t *dq_data;
+// static uint64_t total_pushed = 0;
+static uint64_t total_swapped = 0;
+static void swap(){
+  if(dq == dqA){
+    dq = dqB;
+    dq_other = dqA;
+  }else{
+    dq = dqA;
+    dq_other = dqB;
+  }
+  dq_data = dq->data;
+}
+
+static void produce_wait() ATTRIBUTE(noinline){
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+  dq->ready_to_write = false;
+  while (!dq_other->ready_to_write){
+    // spin
+    usleep(10);
+  }
+  swap();
+  dq->ready_to_read = false;
+  dq_index = 0;
+  total_swapped++;
+}
+
+// the packet is always 128bit, pad  with 0
+static void produce_32(uint32_t x) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, 0, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+#else
+  dq_data[dq_index] = x;
+  // dq_data[dq_index + 1] = 0;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32(uint32_t x, uint32_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index + 1] = y;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_64(uint32_t x, uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  dq_data[dq_index] = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_8_24_32_64(uint8_t x, uint32_t y, uint32_t z, uint64_t w) ATTRIBUTE(noinline){
+  uint32_t xy = (y << 8) | x;
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(z, w, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], xy);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], z);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], w);
+#else
+  dq_data[dq_index] = xy;
+  dq_data[dq_index + 1] = z;
+  *((uint64_t *) &dq_data[dq_index + 2]) = w;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+static void produce_64_64(const uint64_t x, const uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi64x(y, x));
+  // _mm_stream_si64((long long *) &dq_data[dq_index], x);
+  // _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  *((uint64_t *) &dq_data[dq_index]) = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+// static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) {
+static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], z);
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32( z >> 32, z & 0xFFFFFFFF, y, x));
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  *(uint64_t*)&dq_data[dq_index+2] = z;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_32(uint32_t x, uint32_t y, uint32_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, z, y, x));
+
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_si32((int *) &dq_data[dq_index+1], y);
+  // _mm_stream_si32((int *) &dq_data[dq_index+2], z);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  dq_data[dq_index+2] = z;
+  dq_data[dq_index+3] = 0;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+// static void produce_32_64_64(uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline) {
+// #ifdef MM_STREAM
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+1], (__m64)y);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+3], (__m64)z);
+// #else
+  // dq_data[dq_index] = x;
+  // *(uint64_t*)&dq_data[dq_index+1] = y;
+  // *(uint64_t*)&dq_data[dq_index+3] = z;
+// #endif
+  // dq_index += 5;
+  // if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    // produce_wait();
+  // }
+// }
+
+
+// #define CONSUME         sq_consume(the_queue);
+// #define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+#define PRODUCE(x)      produce_32((uint32_t)x);
+
+#define COMBINE_2_32(x,y)   ((((uint64_t)y)<<32) | (uint32_t)(x)) 
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook; \
+  __free_hook = SLAMP_free_hook;
+
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook; \
+  __free_hook = old_free_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+
+// enum DepModAction: char
+// {
+//     INIT = 0,
+//     LOAD,
+//     STORE,
+//     ALLOC,
+//     LOOP_INVOC,
+//     LOOP_ITER,
+//     FINISHED
+// };
+enum ObjectLifetimeModAction : uint32_t {
+  INIT = 0,
+  // LOAD,
+  // STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_EXIT,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  FINISHED
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+
+  // get QUEUE ID from env
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cerr << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+  
+  dqA = segment->find<Queue>("DQ_A").first;
+  dqB = segment->find<Queue>("DQ_B").first;
+  dq = dqA;
+  dq_other = dqB;
+  dq_index = 0;
+  dq_data = dq->data;
+
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // if (the_queue == nullptr) {
+    // std::cout << "Error: could not create queue" << std::endl;
+    // exit(-1);
+  // }
+  // the_queue->data = data;
+  // if (the_queue->data == nullptr) {
+    // std::cout << "Error: could not create queue data" << std::endl;
+    // exit(-1);
+  // }
+
+  // [> Initialize the queue data structure <]
+  // the_queue->p_data = (uint64_t) the_queue->data;
+  // the_queue->c_inx = 0;
+  // the_queue->c_margin = 0;
+  // the_queue->p_glb_inx = 0;
+  // the_queue->c_glb_inx = 0;
+  // the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  // the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // // local_buffer = new LocalBuffer(queue);
+
+  // // send a msg with "fn_id, loop_id"
+  // // char msg[100];
+  // // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  produce_32_32_32(INIT, loop_id, pid);
+
+  auto allocateLibcReqs = [](void *addr, size_t size) {
+    produce_8_24_32_64(ALLOC, 0, size, (uint64_t)addr);
+    // produce_32_32_64(ALLOC, size, (uint64_t)addr);
+  };
+
+  allocateLibcReqs((void*)&errno, sizeof(errno));
+  allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = SLAMP_realloc_hook;
+  __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+  // flush
+  produce_wait();
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE(FINISHED);
+  // sq_flushQueue(the_queue);
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+
+  if (nested_level != 0) {
+    std::cerr << "Error: nested_level != 0 on exit" << std::endl;
+    exit(-1);
+  }
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  // local_buffer->push(ALLOC)->push(addr)->push(size);
+
+  produce_32_32_64(ALLOC, size, addr);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){
+  produce_32_32(FUNC_ENTRY, id);
+}
+
+void SLAMP_exit_fcn(uint32_t id){
+  produce_32_32(FUNC_EXIT, id);
+}
+
+void SLAMP_enter_loop(uint32_t id){
+}
+
+void SLAMP_exit_loop(uint32_t id){
+}
+
+void SLAMP_loop_iter_ctx(uint32_t id){}
+
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  // local_buffer->push(LOOP_INVOC);
+  PRODUCE(LOOP_INVOC);
+
+  counter_ctx++;
+
+  nested_level++;
+  on_profiling = true;
+
+  // if (counter_invoc % 1 == 0) {
+    // on_profiling= true;
+  // }
+  counter_invoc++;
+}
+
+void SLAMP_loop_iteration(){
+  // local_buffer->push(LOOP_ITER);
+  PRODUCE(LOOP_ITER);
+  counter_ctx++;
+
+#ifdef SAMPLING_ITER
+    if (counter_iter % 100 == 0) {
+      on_profiling = true;
+    }
+    if (counter_iter % 100 == 10) { // 0-10000 out of 100000, sampling 10%
+      on_profiling = false;
+    }
+    counter_iter++;
+#endif
+}
+
+void SLAMP_loop_exit(){
+  nested_level--;
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+  PRODUCE(LOOP_EXIT);
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t fcnId, uint32_t argId, void *ptr){
+}
+void SLAMP_report_base_pointer_inst(uint32_t instId, void *ptr){
+}
+
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){
+  ext_fn_inst_id = instr;
+}
+void SLAMP_ext_pop(){
+  ext_fn_inst_id = 0;
+}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // // send a msg with "load, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // //
+  // if (on_profiling) {
+  //   produce_32_32_64(LOAD, instr, addr);
+  //   counter_load++;
+  // }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // // send a msg with "store, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // if (on_profiling) {
+  //   // produce_3(STORE, COMBINE_2_32(instr, bare_instr), addr);
+  //   // produce_64_64(COMBINE_2_32(STORE, instr), addr);
+  //   produce_32_32_64(STORE, instr, addr);
+  //   counter_store++;
+  // }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = malloc(size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  //
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+  // printf("malloc %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* new_ptr = realloc(ptr, size);
+  // local_buffer->push(REALLOC)->push((uint64_t)ptr)->push((uint64_t)new_ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)new_ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)new_ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)new_ptr);
+  // printf("realloc %p to %lu at %p", ptr, size, new_ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return new_ptr;
+}
+
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  TURN_OFF_HOOKS
+  free(ptr);
+  produce_32_64(FREE, (uint64_t)ptr);
+  TURN_ON_HOOKS
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = memalign(alignment, size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+
+  // printf("memalign %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/CustomSend_pt.cpp b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_pt.cpp
new file mode 100644
index 00000000..8cc8fcb6
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/CustomSend_pt.cpp
@@ -0,0 +1,871 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <emmintrin.h>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include <xmmintrin.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#define MM_STREAM
+//#define SAMPLING_ITER
+
+namespace bip = boost::interprocess;
+
+static constexpr uint64_t QSIZE_GUARD = QSIZE - 60;
+
+static unsigned long counter_load = 0;
+static unsigned long counter_store = 0;
+static unsigned long counter_ctx = 0;
+static unsigned long counter_alloc = 0;
+static unsigned long counter_invoc = 0;
+static unsigned long counter_iter = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+static bool on_profiling = false;
+
+static uint32_t ext_fn_inst_id = 0;
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static Queue_p dqA, dqB, dq, dq_other;
+static uint64_t dq_index = 0;
+static uint32_t *dq_data;
+// static uint64_t total_pushed = 0;
+static uint64_t total_swapped = 0;
+static void swap(){
+  if(dq == dqA){
+    dq = dqB;
+    dq_other = dqA;
+  }else{
+    dq = dqA;
+    dq_other = dqB;
+  }
+  dq_data = dq->data;
+}
+
+static void produce_wait() ATTRIBUTE(noinline){
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+  dq->ready_to_write = false;
+  while (!dq_other->ready_to_write){
+    // spin
+    usleep(10);
+  }
+  swap();
+  dq->ready_to_read = false;
+  dq_index = 0;
+  total_swapped++;
+}
+
+// the packet is always 128bit, pad  with 0
+static void produce_32(uint32_t x) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, 0, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+#else
+  dq_data[dq_index] = x;
+  // dq_data[dq_index + 1] = 0;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32(uint32_t x, uint32_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index + 1] = y;
+  // dq_data[dq_index + 2] = 0;
+  // dq_data[dq_index + 3] = 0;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_64(uint32_t x, uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, 0, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  dq_data[dq_index] = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_8_24_32_64(uint8_t x, uint32_t y, uint32_t z, uint64_t w) ATTRIBUTE(noinline){
+  uint32_t xy = (y << 8) | x;
+#ifdef MM_STREAM
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(z, w, y, x));
+  _mm_stream_si32((int *) &dq_data[dq_index], xy);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], z);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], w);
+#else
+  dq_data[dq_index] = xy;
+  dq_data[dq_index + 1] = z;
+  *((uint64_t *) &dq_data[dq_index + 2]) = w;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+static void produce_64_64(const uint64_t x, const uint64_t y) ATTRIBUTE(noinline){
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi64x(y, x));
+  // _mm_stream_si64((long long *) &dq_data[dq_index], x);
+  // _mm_stream_si64((long long *) &dq_data[dq_index + 2], y);
+#else
+  *((uint64_t *) &dq_data[dq_index]) = x;
+  *((uint64_t *) &dq_data[dq_index + 2]) = y;
+#endif
+  dq_index += 4;
+
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+// static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) {
+static void produce_32_32_64(uint32_t x, uint32_t y, uint64_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si32((int *) &dq_data[dq_index], x);
+  _mm_stream_si32((int *) &dq_data[dq_index + 1], y);
+  _mm_stream_si64((long long *) &dq_data[dq_index + 2], z);
+  // _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32( z >> 32, z & 0xFFFFFFFF, y, x));
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  *(uint64_t*)&dq_data[dq_index+2] = z;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+static void produce_32_32_32(uint32_t x, uint32_t y, uint32_t z) ATTRIBUTE(noinline) {
+#ifdef MM_STREAM
+  _mm_stream_si128((__m128i *)(dq_data + dq_index), _mm_set_epi32(0, z, y, x));
+
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_si32((int *) &dq_data[dq_index+1], y);
+  // _mm_stream_si32((int *) &dq_data[dq_index+2], z);
+#else
+  dq_data[dq_index] = x;
+  dq_data[dq_index+1] = y;
+  dq_data[dq_index+2] = z;
+  dq_data[dq_index+3] = 0;
+#endif
+  dq_index += 4;
+  if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    produce_wait();
+  }
+}
+
+
+// static void produce_32_64_64(uint32_t x, uint64_t y, uint64_t z) ATTRIBUTE(noinline) {
+// #ifdef MM_STREAM
+  // _mm_stream_si32((int *) &dq_data[dq_index], x);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+1], (__m64)y);
+  // _mm_stream_pi((__m64*)&dq_data[dq_index+3], (__m64)z);
+// #else
+  // dq_data[dq_index] = x;
+  // *(uint64_t*)&dq_data[dq_index+1] = y;
+  // *(uint64_t*)&dq_data[dq_index+3] = z;
+// #endif
+  // dq_index += 5;
+  // if (dq_index >= QSIZE_GUARD) [[unlikely]] {
+    // produce_wait();
+  // }
+// }
+
+
+// #define CONSUME         sq_consume(the_queue);
+// #define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+#define PRODUCE(x)      produce_32((uint32_t)x);
+
+#define COMBINE_2_32(x,y)   ((((uint64_t)y)<<32) | (uint32_t)(x)) 
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook; \
+  __free_hook = SLAMP_free_hook;
+
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook; \
+  __free_hook = old_free_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+
+// enum DepModAction: char
+// {
+//     INIT = 0,
+//     LOAD,
+//     STORE,
+//     ALLOC,
+//     LOOP_INVOC,
+//     LOOP_ITER,
+//     FINISHED
+// };
+enum PointsToModAction : uint32_t {
+  INIT = 0,
+  // LOAD,
+  // STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_ENTRY,
+  LOOP_EXIT,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  POINTS_TO_INST,
+  POINTS_TO_ARG,
+  FINISHED
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+
+  // get QUEUE ID from env
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cerr << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+  
+  dqA = segment->find<Queue>("DQ_A").first;
+  dqB = segment->find<Queue>("DQ_B").first;
+  dq = dqA;
+  dq_other = dqB;
+  dq_index = 0;
+  dq_data = dq->data;
+
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // if (the_queue == nullptr) {
+    // std::cout << "Error: could not create queue" << std::endl;
+    // exit(-1);
+  // }
+  // the_queue->data = data;
+  // if (the_queue->data == nullptr) {
+    // std::cout << "Error: could not create queue data" << std::endl;
+    // exit(-1);
+  // }
+
+  // [> Initialize the queue data structure <]
+  // the_queue->p_data = (uint64_t) the_queue->data;
+  // the_queue->c_inx = 0;
+  // the_queue->c_margin = 0;
+  // the_queue->p_glb_inx = 0;
+  // the_queue->c_glb_inx = 0;
+  // the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  // the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // // local_buffer = new LocalBuffer(queue);
+
+  // // send a msg with "fn_id, loop_id"
+  // // char msg[100];
+  // // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  produce_32_32_32(INIT, loop_id, pid);
+
+  auto allocateLibcReqs = [](void *addr, size_t size) {
+    produce_8_24_32_64(ALLOC, 0, size, (uint64_t)addr);
+    // produce_32_32_64(ALLOC, size, (uint64_t)addr);
+  };
+
+  allocateLibcReqs((void*)&errno, sizeof(errno));
+  allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = SLAMP_realloc_hook;
+  __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+  // flush
+  produce_wait();
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE(FINISHED);
+  // sq_flushQueue(the_queue);
+  dq->size = dq_index;
+  dq->ready_to_read = true;
+
+  if (nested_level != 0) {
+    std::cerr << "Error: nested_level != 0 on exit" << std::endl;
+    exit(-1);
+  }
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  // local_buffer->push(ALLOC)->push(addr)->push(size);
+
+  produce_32_32_64(ALLOC, size, addr);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){
+  produce_32_32(FUNC_ENTRY, id);
+}
+
+void SLAMP_exit_fcn(uint32_t id){
+  produce_32_32(FUNC_EXIT, id);
+}
+
+void SLAMP_enter_loop(uint32_t id){
+  produce_32_32(LOOP_ENTRY, id);
+}
+
+void SLAMP_exit_loop(uint32_t id){
+  produce_32_32(LOOP_EXIT, id);
+}
+
+void SLAMP_loop_iter_ctx(uint32_t id){}
+
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  // local_buffer->push(LOOP_INVOC);
+  PRODUCE(LOOP_INVOC);
+
+  counter_ctx++;
+
+  nested_level++;
+  on_profiling = true;
+
+  // if (counter_invoc % 1 == 0) {
+    // on_profiling= true;
+  // }
+  counter_invoc++;
+}
+
+void SLAMP_loop_iteration(){
+  // local_buffer->push(LOOP_ITER);
+  PRODUCE(LOOP_ITER);
+  counter_ctx++;
+
+#ifdef SAMPLING_ITER
+    if (counter_iter % 100 == 0) {
+      on_profiling = true;
+    }
+    if (counter_iter % 100 == 10) { // 0-10000 out of 100000, sampling 10%
+      on_profiling = false;
+    }
+    counter_iter++;
+#endif
+}
+
+void SLAMP_loop_exit(){
+  nested_level--;
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t fcnId, uint32_t argId, void *ptr){
+  // FIXME: combine fcnid and argid to 32 bit
+  uint32_t id = (fcnId << 16) | (argId & 0xffff);
+
+  produce_32_32_64(POINTS_TO_ARG, id, (uint64_t)ptr);
+}
+void SLAMP_report_base_pointer_inst(uint32_t instId, void *ptr){
+  produce_32_32_64(POINTS_TO_INST, instId, (uint64_t)ptr);
+}
+
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){
+  ext_fn_inst_id = instr;
+}
+void SLAMP_ext_pop(){
+  ext_fn_inst_id = 0;
+}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // // send a msg with "load, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // //
+  // if (on_profiling) {
+  //   produce_32_32_64(LOAD, instr, addr);
+  //   counter_load++;
+  // }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // // send a msg with "store, instr, addr, bare_instr, value"
+  // // char msg[100];
+  // // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // if (on_profiling) {
+  //   // produce_3(STORE, COMBINE_2_32(instr, bare_instr), addr);
+  //   // produce_64_64(COMBINE_2_32(STORE, instr), addr);
+  //   produce_32_32_64(STORE, instr, addr);
+  //   counter_store++;
+  // }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = malloc(size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  //
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+  // printf("malloc %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* new_ptr = realloc(ptr, size);
+  // local_buffer->push(REALLOC)->push((uint64_t)ptr)->push((uint64_t)new_ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)new_ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)new_ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)new_ptr);
+  // printf("realloc %p to %lu at %p", ptr, size, new_ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return new_ptr;
+}
+
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  TURN_OFF_HOOKS
+  free(ptr);
+  produce_32_64(FREE, (uint64_t)ptr);
+  TURN_ON_HOOKS
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = memalign(alignment, size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  // produce_3(ALLOC, (uint64_t)ptr, size);
+  produce_8_24_32_64(ALLOC, ext_fn_inst_id, size, (uint64_t)ptr);
+  // produce_32_32_64(ALLOC, size, (uint64_t)ptr);
+
+  // printf("memalign %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/bitcast.h b/liberty/lib/SLAMP/SLAMPcustom/bitcast.h
new file mode 100644
index 00000000..404a9a99
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/bitcast.h
@@ -0,0 +1,29 @@
+#ifndef BITCAST_H
+#define BITCAST_H
+
+typedef union { double d; int64_t i; } SQ_DI;
+typedef union { float f; int32_t i; } SQ_FI;
+
+Inline int64_t doubleToInt(double d) {
+  SQ_DI conv;
+  conv.d = d;
+  return conv.i;
+}
+Inline int64_t floatToInt(float f) {
+  SQ_FI conv;
+  conv.f = f;
+  return conv.i;
+}
+Inline double intToDouble(int64_t i) {
+  SQ_DI conv;
+  conv.i = (int32_t)i;
+  return conv.d;
+}
+
+Inline float intToFloat(int64_t i) {
+  SQ_FI conv;
+  conv.i = (int32_t)i;
+  return conv.f;
+}
+
+#endif /* BITCAST_H */
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/.gitignore b/liberty/lib/SLAMP/SLAMPcustom/consumer/.gitignore
new file mode 100644
index 00000000..378eac25
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPcustom/consumer/CMakeLists.txt
new file mode 100644
index 00000000..f84fe941
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/CMakeLists.txt
@@ -0,0 +1,26 @@
+cmake_minimum_required (VERSION 3.6.2 FATAL_ERROR)
+
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+set(CMAKE_LINKER "ld.gold")
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+# set C++17
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+set(LINK_FLAGS "${LINK_FLAGS} -flto")
+
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+include_directories(./
+    ../)
+
+add_executable (consumer consumer.cpp ProfilingModules/DependenceModule.cpp ProfilingModules/PointsToModule.cpp ProfilingModules/LoadedValueModule.cpp ProfilingModules/ObjectLifetimeModule.cpp)
+target_link_libraries(consumer LINK_PUBLIC 
+	${Boost_LIBRARIES}
+	rt
+	Threads::Threads
+)
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ContextManager.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ContextManager.h
new file mode 100644
index 00000000..f91e0337
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ContextManager.h
@@ -0,0 +1,142 @@
+#pragma once
+
+#include "ProfilingModules/context.h"
+#include <cassert>
+#include <iostream>
+#include <stack>
+#include <unordered_map>
+#include <utility>
+#include <map>
+#include <vector>
+
+
+// namespace SpecPrivLib {
+// enum SpecPrivContextType {
+  // TopContext = 0,
+  // FunctionContext,
+  // LoopContext,
+// };
+
+#define CONTEXT_DEBUG 0
+
+template <class TypeEnum, typename MetaIdType>
+struct ContextId {
+  static_assert(TypeEnum::TopContext == 0, "TopContext must be 0");
+
+  TypeEnum type;
+  MetaIdType metaId;
+  ContextId(TypeEnum type, MetaIdType id) : type(type), metaId(id) {}
+  ContextId(std::pair<TypeEnum, MetaIdType> p)
+      : type(p.first), metaId(p.second) {}
+  static ContextId getTopContextId() { return {TypeEnum::TopContext, 0}; }
+  // id left shift 2 bits and or with type
+  // ContextHash hash() {
+    // return (static_cast<ContextHash>(metaId) << 2) | static_cast<ContextHash>(type);
+  // }
+
+  bool operator==(const ContextId &other) const {
+    return type == other.type && metaId == other.metaId;
+  }
+
+  bool operator!=(const ContextId &other) const {
+    return !(*this == other);
+  }
+
+  bool operator<(const ContextId &other) const {
+    return type < other.type || (type == other.type && metaId < other.metaId);
+  }
+
+  void print(std::ostream &os) {
+    os << "(" << type << "," << metaId << ")";
+  }
+};
+
+template <class TypeEnum, typename MetaIdType, typename HashType = size_t>
+class NewContextManager {
+  using ContextId = ContextId<TypeEnum, MetaIdType>;
+  std::vector<ContextId> contextStack;
+
+  // FIXME: fix this hashing problem
+  std::map<std::vector<ContextId>, HashType> contextToHashMap;
+  std::vector<std::vector<ContextId>> hashToContextMap;
+  size_t contextIdHashCounter = 1; // avoid 0
+  bool cached = false;
+  HashType cachedContextHash;
+
+public:
+  NewContextManager() {
+    contextStack.push_back(ContextId::getTopContextId());
+    hashToContextMap.push_back(contextStack);
+  }
+
+  ~NewContextManager() = default;
+
+  void pushContext(ContextId contextId) {
+    cached = false;
+    contextStack.push_back(contextId); 
+  }
+
+  void popContext(ContextId contextId) {
+    cached = false;
+    if (contextStack.back() == contextId) {
+      contextStack.pop_back();
+    } else {
+      if (CONTEXT_DEBUG) {
+        std::cerr << "ContextManager: popContext: context not found: ";
+        contextId.print(std::cerr);
+        std::cerr << "ContextManager: popContext: stack: ";
+        for (auto &c : contextStack) {
+          c.print(std::cerr);
+        }
+        std::cerr << "\n";
+      }
+      // keep popping until we find the context
+      while (contextStack.back() != contextId && contextStack.back() != ContextId::getTopContextId()) {
+        contextStack.pop_back();
+      }
+
+      if (contextStack.back() == contextId) {
+        contextStack.pop_back();
+      } else {
+        if (CONTEXT_DEBUG) {
+          std::cerr << "ContextManager: popContext: context not found: ";
+        }
+      }
+    }
+  }
+
+  HashType encodeContext(std::vector<ContextId> context) {
+    if (contextToHashMap.count(context)) {
+      return contextToHashMap[context];
+    } else {
+      contextToHashMap[context] = contextIdHashCounter;
+      hashToContextMap.push_back(context);
+
+      return contextIdHashCounter++;
+    }
+  }
+
+  HashType encodeActiveContext() {
+    if (cached) {
+      return cachedContextHash;
+    } else {
+      cached = true;
+      cachedContextHash = encodeContext(contextStack);
+      return cachedContextHash;
+    }
+  }
+
+  std::vector<ContextId> decodeContext(HashType hash) {
+    assert(hash < hashToContextMap.size() && hash != 0 && "invalid hash");
+    return hashToContextMap[hash];
+  }
+
+  void printContext(std::ostream &os, HashType hash) {
+    assert(hash < hashToContextMap.size() && hash != 0 && "invalid hash");
+    auto &context = hashToContextMap[hash];
+    for (auto it = context.rbegin(); it != context.rend(); it++) {
+      auto &c = *it;
+      c.print(os);
+    }
+  }
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.cpp b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.cpp
new file mode 100644
index 00000000..5cee1292
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.cpp
@@ -0,0 +1,211 @@
+#include <cstdint>
+#include <fstream>
+#include <map>
+#include <set>
+#include <thread>
+#include <unordered_set>
+#include <vector>
+
+#include "DependenceModule.h"
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "slamp_timestamp.h"
+
+// static std::map<uint32_t, uint64_t> *inst_count;
+static inline uint64_t rdtsc() {
+  uint64_t a, d;
+  __asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
+  return (d << 32) | a;
+}
+
+// init: setup the shadow memory
+void DependenceModule::init(uint32_t loop_id, uint32_t pid) {
+  target_loop_id = loop_id;
+
+#define SIZE_8M  0x800000
+  smmap->init_stack(SIZE_8M, pid);
+  // inst_count = new std::map<uint32_t, uint64_t>();
+
+}
+
+// static uint64_t log_time = 0;
+
+
+void DependenceModule::fini(const char *filename) {
+  // std::cout << "Load count: " << load_count << std::endl;
+  // std::cout << "Store count: " << store_count << std::endl;
+
+  std::ofstream of(filename);
+  of << target_loop_id << " " << 0 << " " << 0 << " "
+       << 0 << " " << 0 << " " << 0 << "\n";
+
+#ifdef TRACK_COUNT
+  // get all the keys of a hash table to ordered set
+  std::set<slamp::KEY, slamp::KEYComp> ordered;
+  for (auto & it : deps) {
+    ordered.insert(it.first);
+  }
+#else
+  std::set<slamp::KEY, slamp::KEYComp> ordered(deps.begin(), deps.end());
+#endif
+
+  for (auto &k: ordered) {
+#ifdef TRACK_COUNT
+    auto count = deps[k];
+#else
+    auto count = 1;
+#endif
+    of << target_loop_id << " " << k.src << " " << k.dst << " " << k.dst_bare << " "
+        << (k.cross ? 1 : 0) << " " << count << " ";
+#ifdef TRACK_MIN_DISTANCE
+    auto dist = min_dist[k];
+    of << dist;
+#endif
+    of << "\n";
+  }
+  of.close();
+
+  // std::cout << "Log time: " << log_time/ 2.6e9 << " s" << std::endl;
+
+  // for (auto &i : *inst_count) {
+  //   of << target_loop_id << " " << i.first << " " << i.second << "\n";
+  // }
+
+#ifdef COLLECT_TRACE
+  // dump the dep trace to a binary file
+  std::ofstream trace_file("dep_trace.bin", std::ios::binary);
+  trace_file.write((char *)dep_trace.data(), dep_trace.size() * sizeof(slamp::KEY));
+  trace_file.close();
+#endif
+}
+
+void DependenceModule::allocate(void *addr, uint64_t size) {
+  smmap->allocate(addr, size);
+}
+
+void DependenceModule::log(TS ts, const uint32_t dst_inst, const uint32_t context){
+
+    uint32_t src_inst = GET_INSTR(ts);
+
+    uint64_t src_invoc = GET_INVOC(ts);
+    uint64_t src_iter = GET_ITER(ts);
+
+    if (src_invoc != GET_INVOC(slamp_invocation)) {
+      return;
+    }
+
+#ifdef TRACK_CONTEXT
+    slamp::KEY key(src_inst, dst_inst, context, src_iter != slamp_iteration);
+#else
+    slamp::KEY key(src_inst, dst_inst, 0, src_iter != slamp_iteration);
+#endif
+
+
+#ifdef TRACK_MIN_DISTANCE
+    auto dist = slamp_iteration - src_iter;
+    min_dist.emplace({key, dist});
+#endif
+
+    deps.emplace(key);
+
+#ifdef COLLECT_TRACE
+    if (dep_trace_idx < dep_trace_size) {
+      dep_trace.emplace_back(key);
+      dep_trace_idx++;
+    }
+#endif
+}
+
+void DependenceModule::load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr) {
+  local_write(addr, [&]() {
+    // load_count++;
+
+    // if tracking multiple loops
+
+    TS *s = (TS *)GET_SHADOW(addr, DM_TIMESTAMP_SIZE_IN_BYTES_LOG2);
+
+    TS tss = s[0];
+    if (tss != 0) {
+      // uint64_t start = rdtsc();
+      log(tss, instr, context);
+      // uint64_t end = rdtsc();
+      // log_time += end - start;
+    }
+#ifdef TRACK_WAR
+#ifdef TRACK_CONTEXT
+    if (context != 0)
+      instr = context;
+#endif
+    TS ts = CREATE_TS(instr, slamp_iteration, slamp_invocation);
+    s[1] = ts;
+#endif
+  });
+}
+
+void DependenceModule::store(uint32_t instr, uint32_t bare_instr, const uint64_t addr)  {
+
+  local_write(addr, [&]() {
+    // store_count++;
+    TS *shadow_addr = (TS *)GET_SHADOW(addr, DM_TIMESTAMP_SIZE_IN_BYTES_LOG2);
+
+#ifdef TRACK_WAW
+    if (shadow_addr[0] != 0) {
+      // uint64_t start = rdtsc();
+      log(shadow_addr[0], instr, context);
+      // uint64_t end = rdtsc();
+      // log_time += end - start;
+    }
+#endif
+
+#ifdef TRACK_WAR
+    if (shadow_addr[1] != 0) {
+      // uint64_t start = rdtsc();
+      log(shadow_addr[1], instr, context);
+      // uint64_t end = rdtsc();
+      // log_time += end - start;
+    }
+#endif
+
+#ifdef TRACK_CONTEXT
+    if (context != 0)
+      instr = context;
+#endif
+    TS ts = CREATE_TS(instr, slamp_iteration, slamp_invocation);
+    shadow_addr[0] = ts;
+
+
+  });
+}
+
+void DependenceModule::loop_invoc() {
+  slamp_iteration = 0;
+  slamp_invocation++;
+  nested_level++;
+}
+
+void DependenceModule::loop_iter() {
+  slamp_iteration++;
+}
+
+void DependenceModule::loop_exit() {
+  nested_level--;
+}
+
+void DependenceModule::func_entry(uint32_t instr) {
+  if (nested_level == 1) {
+    context = instr;
+  }
+}
+
+void DependenceModule::func_exit(uint32_t instr) {
+  if (nested_level == 1) {
+    context = 0;
+  }
+}
+
+void DependenceModule::merge_dep(DependenceModule &other) {
+   deps.merge(other.deps);
+#ifdef TRACK_MIN_DISTANCE
+   min_dist.merge(other.min_dist);
+#endif
+}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.h
new file mode 100644
index 00000000..efcab04f
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/DependenceModule.h
@@ -0,0 +1,104 @@
+#include <cstdint>
+#include <mutex>
+#include <unordered_set>
+#include <vector>
+
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "slamp_timestamp.h"
+
+#include "LocalWriteModule.h"
+#include "HTContainer.h"
+
+// #define TRACK_COUNT
+// #define TRACK_MIN_DISTANCE
+
+#define TRACK_CONTEXT
+
+// #define TRACK_WAW
+// #define TRACK_WAR
+
+#ifdef TRACK_WAR
+#define DM_TIMESTAMP_SIZE_IN_BYTES 16
+#define DM_TIMESTAMP_SIZE_IN_BYTES_LOG2 4
+#else
+#define DM_TIMESTAMP_SIZE_IN_BYTES 8
+#define DM_TIMESTAMP_SIZE_IN_BYTES_LOG2 3
+#endif
+
+// #define COLLECT_TRACE
+
+enum class DepModAction : uint32_t{
+  INIT = 0,
+  LOAD,
+  STORE,
+  ALLOC,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_EXIT,
+  FINISHED,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+};
+
+class DependenceModule : public LocalWriteModule {
+private:
+  uint64_t slamp_iteration = 0;
+  uint64_t slamp_invocation = 0;
+  uint32_t target_loop_id = 0;
+
+  // debugging stats
+  uint64_t load_count = 0;
+  uint64_t store_count = 0;
+
+  unsigned int context = 0;
+  int nested_level = 0;
+
+#ifdef COLLECT_TRACE
+  // Collect trace
+  std::vector<slamp::KEY> dep_trace;
+  static constexpr unsigned dep_trace_size = 10'000'000;
+  unsigned dep_trace_idx = 0;
+#endif
+
+
+  slamp::MemoryMap<MASK2> *smmap = nullptr;
+
+#ifdef TRACK_COUNT
+  HTMap_Sum<slamp::KEY, slamp::KEYHash, slamp::KEYEqual, 16> deps;
+#else
+  // HTSet<slamp::KEY, slamp::KEYHash, slamp::KEYEqual, 16> deps;
+  phmap::flat_hash_set<slamp::KEY, slamp::KEYHash, slamp::KEYEqual> deps;
+#endif
+
+#ifdef TRACK_MIN_DISTANCE
+  HTMap_Min<slamp::KEY, slamp::KEYHash, slamp::KEYEqual, 16> min_dist;
+#endif
+
+  void log(TS ts, const uint32_t dst_inst, const uint32_t bare_inst);
+
+public:
+  DependenceModule(uint32_t mask, uint32_t pattern)
+      : LocalWriteModule(mask, pattern) {
+    smmap = new slamp::MemoryMap(mask, pattern, DM_TIMESTAMP_SIZE_IN_BYTES);
+#ifdef COLLECT_TRACE
+    dep_trace.reserve(dep_trace_size + 10); // 10M
+#endif
+  }
+
+  ~DependenceModule() override { delete smmap; }
+
+  void init(uint32_t loop_id, uint32_t pid);
+  void fini(const char *filename);
+  // always_inline attribute
+  void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr);
+  void store(uint32_t instr, uint32_t bare_instr, const uint64_t addr);
+  void allocate(void *addr, uint64_t size);
+  void loop_invoc();
+  void loop_iter();
+  void loop_exit();
+  void func_entry(uint32_t context);
+  void func_exit(uint32_t context);
+
+  void merge_dep(DependenceModule &other);
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/HTContainer.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/HTContainer.h
new file mode 100644
index 00000000..e8165711
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/HTContainer.h
@@ -0,0 +1,1446 @@
+/*
+ * HT (High Throughput) Containers
+ * Author: Ziyang Xu
+ * 
+ * Use vector as buffer and use parallelism to improve performance
+ * This can replace set and map in STL
+ *
+ */
+#pragma once
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <unistd.h>
+#include <vector>
+#include <fstream>
+
+#define HT
+// #define ADAPTIVE_HT
+#define PB
+
+#ifdef PB
+#include "parallel_hashmap/phmap.h"
+#else
+#include <unordered_set>
+#endif
+
+
+#ifdef PB
+#define hash_set phmap::flat_hash_set
+#define hash_map phmap::flat_hash_map
+#else
+#define hash_set std::unordered_set
+#define hash_map std::unordered_map
+#endif
+
+#define HT_THREAD_POOL
+#define CACHELINE_SIZE 64
+
+
+template <typename T, typename Hash = std::hash<T>,
+          typename KeyEqual = std::equal_to<T>,
+          uint32_t MAX_THREAD = 56,
+          uint32_t BUFFER_SIZE = 1'000'000>
+class HTSet {
+
+    public:
+      void Start() {
+      }
+
+    private:
+#ifdef HT_THREAD_POOL
+      bool should_terminate = false;           // Tells threads to stop looking for jobs
+      std::mutex queue_mutex;                  // Prevents data races to the job queue
+      std::condition_variable mutex_condition; // Allows threads to wait on new jobs or termination 
+      std::vector<std::thread> threads;
+      volatile int pending_jobs = 0;           // Number of jobs that have not been completed
+      // avoid false sharing
+
+      std::vector<bool> ready;
+
+      void ThreadLoop(const int id) {
+        auto set_chunk = std::make_unique<hash_set<T, Hash, KeyEqual>>();
+
+        const auto thread_count = MAX_THREAD;
+        auto job = [&]() {
+          const auto set_size = buffer.size() / thread_count;
+          const auto buffer_size = buffer.size();
+          // take the chunk and convert to a set and return
+          // set_chunk->reserve(set_size);
+
+          auto begin = id * (buffer_size / thread_count);
+          auto end = (id + 1) * (buffer_size / thread_count);
+
+          set_chunk->insert(buffer.begin() + begin, buffer.begin() + end);
+
+          m.lock();
+          // lock the global set and insert the chunk
+          set.insert(set_chunk->begin(), set_chunk->end());
+          m.unlock();
+          set_chunk->clear();
+        };
+        while (true) {
+          {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            mutex_condition.wait(lock, [this, id] { return ready[id * CACHELINE_SIZE]  || should_terminate; });
+            // std::cout << "Thread " << id << " is running" << std::endl;
+            if (should_terminate) {
+              return;
+            }
+          }
+          job();
+          ready[id * CACHELINE_SIZE] = false;
+          {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            pending_jobs--;
+          }
+        }
+      }
+#endif
+
+
+private:
+  std::vector<T> buffer;
+  std::mutex m;
+  using hash_set_t = hash_set<T, Hash, KeyEqual>;
+
+public:
+  hash_set_t set;
+  HTSet() {
+    buffer.reserve(BUFFER_SIZE);
+#ifdef HT_THREAD_POOL
+    const uint32_t num_threads = MAX_THREAD;
+    threads.resize(num_threads);
+
+    ready.resize(num_threads * CACHELINE_SIZE);
+    for (uint32_t i = 0; i < num_threads; i++) {
+      threads[i] = std::thread(&HTSet::ThreadLoop, this, i);
+      ready[i * CACHELINE_SIZE] = false;
+      // threads.at(i) = std::thread(ThreadLoop, i);
+    }
+#endif
+  }
+
+  ~HTSet() {
+#ifdef HT_THREAD_POOL
+    should_terminate = true;
+    mutex_condition.notify_all();
+    for (auto &thread : threads) {
+      thread.join();
+    }
+#endif
+  }
+
+  bool count(const T &key) {
+    return set.count(key);
+  }
+
+  void emplace_back(T &&t) {
+#ifdef HT
+    buffer.emplace_back(std::move(t));
+    checkBuffer();
+#else
+    set.emplace(std::move(t));
+#endif
+  }
+
+  void emplace_back(const T &t) {
+#ifdef HT
+    buffer.emplace_back(t);
+    checkBuffer();
+#else
+    set.emplace(t);
+#endif
+  }
+
+  void emplace(T &&t) {
+    emplace_back(t);
+  }
+
+  // the same as emplace_back
+  void emplace(const T &t) {
+    emplace_back(t);
+  }
+
+  // iterator begin
+  auto begin() {
+    convertVectorToSet();
+    return set.begin();
+  }
+
+  // iterator end
+  auto end() {
+    convertVectorToSet();
+    return set.end();
+  }
+
+  void merge(HTSet &other) {
+    merge(other.begin(), other.end());
+  }
+
+  // insert (begin, end)
+  void merge(typename hash_set_t::iterator begin, typename hash_set_t::iterator end) {
+    for (auto it = begin; it != end; ++it) {
+      set.insert(*it);
+    }
+  }
+
+
+private:
+  const uint32_t getThreadCount() {
+#ifdef ADAPTIVE_HT
+    // TODO: adaptive thread count, measure the performance benefit of this
+    // get current active number of threads from /proc/loadavg
+    std::ifstream loadavg("/proc/loadavg");
+
+    // get active threads count
+    // ignore the first three fp numbers, find the 4th int number (before "/")
+    std::string load;
+    for (int i = 0; i < 3; i++) {
+      loadavg >> load;
+    }
+    loadavg >> load;
+    loadavg.close();
+    load = load.substr(0, load.find('/'));
+    int active_threads = std::stoi(load);
+
+    uint32_t MAX_CORES = 56;
+
+    int running_threads = MAX_CORES - active_threads;
+    // max(1, running_threads)
+    running_threads = running_threads > 0 ? running_threads : 1;
+    // min(MAX_THREAD, running_threads)
+    running_threads = running_threads < MAX_THREAD ? running_threads : MAX_THREAD;
+
+
+    // std::cout << "active threads: " << running_threads << std::endl;
+
+    return running_threads;
+#else
+    return MAX_THREAD;
+#endif
+  }
+
+  inline void checkBuffer() {
+    if (buffer.size() == BUFFER_SIZE) {
+      convertVectorToSet();
+      buffer.resize(0);
+      buffer.reserve(BUFFER_SIZE);
+    }
+  }
+
+  void convertVectorToSet() {
+    const uint32_t thread_count = getThreadCount();
+    const auto set_size = buffer.size() / thread_count;
+    const auto buffer_size = buffer.size();
+
+    if (buffer_size == 0) {
+      return;
+    }
+
+    if (thread_count == 1) {
+      set.insert(buffer.begin(), buffer.end());
+      return;
+    }
+
+#ifdef HT_THREAD_POOL
+    pending_jobs = thread_count;
+
+    for (uint32_t i = 0; i < thread_count; i++) {
+      ready[i * CACHELINE_SIZE] = true;
+    }
+
+    // std::cout << "pending jobs: " << pending_jobs << std::endl;
+    mutex_condition.notify_all();
+
+    // std:: cout << "waiting for jobs to finish" << std::endl;
+
+    // busy wait: check if all threads are done
+    while (true) {
+      // std::cout << "pending jobs: " << pending_jobs << std::endl;
+      if (pending_jobs == 0) {
+        break;
+      }
+    }
+#endif
+
+#ifndef HT_THREAD_POOL
+    // launch N threads to convert the vector to set independently, chunking
+    std::thread t[thread_count];
+    for (unsigned long i = 0; i < thread_count; i++) {
+      t[i] = std::thread(
+          [&](int id) {
+            // take the chunk and convert to a set and return
+            auto *set_chunk = new hash_set<T, Hash, KeyEqual>();
+            set_chunk->reserve(set_size);
+
+            auto begin = id * (buffer_size / thread_count);
+            auto end = (id + 1) * (buffer_size / thread_count);
+
+            set_chunk->insert(buffer.begin() + begin, buffer.begin() + end);
+
+            m.lock();
+            // lock the global set and insert the chunk
+            set.insert(set_chunk->begin(), set_chunk->end());
+            m.unlock();
+            delete set_chunk;
+          },
+          i);
+    }
+    // join the threads
+    for (auto &i : t) {
+      i.join();
+    }
+#endif
+  }
+};
+
+// HTMap_Redux, HTMap_T_Set
+template <typename T, typename Hash = std::hash<T>,
+          typename KeyEqual = std::equal_to<T>,
+          uint32_t MAX_THREAD = 16,
+          uint32_t BUFFER_SIZE = 1'000'000>
+class HTMap_Sum {
+  using MyType = HTMap_Sum<T, Hash, KeyEqual, MAX_THREAD, BUFFER_SIZE>;
+
+    public:
+      void Start() {
+      }
+
+    private:
+#ifdef HT_THREAD_POOL
+      bool should_terminate = false;           // Tells threads to stop looking for jobs
+      std::mutex queue_mutex;                  // Prevents data races to the job queue
+      std::condition_variable mutex_condition; // Allows threads to wait on new jobs or termination 
+      std::vector<std::thread> threads;
+      volatile int pending_jobs = 0;           // Number of jobs that have not been completed
+      // avoid false sharing
+
+      std::vector<bool> ready;
+
+      void ThreadLoop(const int id) {
+        auto map_chunk = std::make_unique<hash_map<T, unsigned, Hash, KeyEqual>>();
+
+        const auto thread_count = MAX_THREAD;
+        auto job = [&]() {
+          const auto set_size = buffer.size() / thread_count;
+          const auto buffer_size = buffer.size();
+
+          auto begin = id * (buffer_size / thread_count);
+          auto end = (id + 1) * (buffer_size / thread_count);
+
+          // for each element in the chunk, insert into the map, and increment the count
+          // from begin to end
+          for (auto it = buffer.begin() + begin; it != buffer.begin() + end; ++it) {
+            auto key = *it;
+            auto search = map_chunk->find(key);
+            if (search != map_chunk->end()) {
+              search->second++;
+            } else {
+              map_chunk->insert({key, 1});
+            }
+          }
+
+          m.lock();
+          // lock the global set and insert the chunk
+          // merge the map_chunk into the global map
+          for (auto it = map_chunk->begin(); it != map_chunk->end(); ++it) {
+            auto global_it = map.find(it->first);
+            if (global_it == map.end()) {
+              map.insert({it->first, it->second});
+            } else {
+              global_it->second += it->second;
+            }
+          }
+          m.unlock();
+          map_chunk->clear();
+        };
+        while (true) {
+          {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            mutex_condition.wait(lock, [this, id] { return ready[id * CACHELINE_SIZE]  || should_terminate; });
+            // std::cout << "Thread " << id << " is running" << std::endl;
+            if (should_terminate) {
+              return;
+            }
+          }
+          job();
+          ready[id * CACHELINE_SIZE] = false;
+          {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            pending_jobs--;
+          }
+        }
+      }
+#endif
+
+
+private:
+  std::vector<T> buffer;
+  std::mutex m;
+  using hash_map_t = hash_map<T, unsigned, Hash, KeyEqual>;
+
+public:
+  hash_map_t map;
+  HTMap_Sum() {
+    buffer.reserve(BUFFER_SIZE);
+#ifdef HT_THREAD_POOL
+    const uint32_t num_threads = MAX_THREAD;
+    threads.resize(num_threads);
+
+    ready.resize(num_threads * CACHELINE_SIZE);
+    for (uint32_t i = 0; i < num_threads; i++) {
+      threads[i] = std::thread(&HTMap_Sum::ThreadLoop, this, i);
+      ready[i * CACHELINE_SIZE] = false;
+      // threads.at(i) = std::thread(ThreadLoop, i);
+    }
+#endif
+  }
+
+  ~HTMap_Sum() {
+#ifdef HT_THREAD_POOL
+    should_terminate = true;
+    mutex_condition.notify_all();
+    for (auto &thread : threads) {
+      thread.join();
+    }
+#endif
+  }
+
+  void emplace_back(T &&t) {
+#ifdef HT
+    buffer.emplace_back(std::move(t));
+    checkBuffer();
+#else
+    set.emplace(std::move(t));
+#endif
+  }
+
+  void emplace_back(const T &t) {
+#ifdef HT
+    buffer.emplace_back(t);
+    checkBuffer();
+#else
+    set.emplace(t);
+#endif
+  }
+
+  void emplace(T &&t) {
+    emplace_back(t);
+  }
+
+  // the same as emplace_back
+  void emplace(const T &t) {
+    emplace_back(t);
+  }
+
+  // iterator begin
+  auto begin() {
+    convertVectorToSet();
+    return map.begin();
+  }
+
+  // iterator end
+  auto end() {
+    convertVectorToSet();
+    return map.end();
+  }
+
+  // provide [] operator
+  auto &operator[](const T &key) {
+    convertVectorToSet();
+    return map[key];
+  }
+
+  void merge(MyType &other) {
+    merge(other.begin(), other.end());
+  }
+
+  // insert (begin, end)
+  void merge(typename hash_map_t::iterator begin, typename hash_map_t::iterator end) {
+    convertVectorToSet();
+    for (auto it = begin; it != end; ++it) {
+      auto global_it = map.find(it->first);
+      if (global_it == map.end()) {
+        map.insert({it->first, it->second});
+      } else {
+        global_it->second += it->second;
+      }
+    }
+  }
+
+
+private:
+  const uint32_t getThreadCount() {
+#ifdef ADAPTIVE_HT
+    // TODO: adaptive thread count, measure the performance benefit of this
+    // get current active number of threads from /proc/loadavg
+    std::ifstream loadavg("/proc/loadavg");
+
+    // get active threads count
+    // ignore the first three fp numbers, find the 4th int number (before "/")
+    std::string load;
+    for (int i = 0; i < 3; i++) {
+      loadavg >> load;
+    }
+    loadavg >> load;
+    loadavg.close();
+    load = load.substr(0, load.find('/'));
+    int active_threads = std::stoi(load);
+
+    uint32_t MAX_CORES = 56;
+
+    int running_threads = MAX_CORES - active_threads;
+    // max(1, running_threads)
+    running_threads = running_threads > 0 ? running_threads : 1;
+    // min(MAX_THREAD, running_threads)
+    running_threads = running_threads < MAX_THREAD ? running_threads : MAX_THREAD;
+
+
+    // std::cout << "active threads: " << running_threads << std::endl;
+
+    return running_threads;
+#else
+    return MAX_THREAD;
+#endif
+  }
+
+  inline void checkBuffer() {
+    if (buffer.size() == BUFFER_SIZE) {
+      convertVectorToSet();
+      buffer.resize(0);
+      buffer.reserve(BUFFER_SIZE);
+    }
+  }
+
+  void convertVectorToSet() {
+    const uint32_t thread_count = getThreadCount();
+    const auto set_size = buffer.size() / thread_count;
+    const auto buffer_size = buffer.size();
+
+    if (buffer_size == 0) {
+      return;
+    }
+
+    if (thread_count == 1) {
+      // merge the buffer to the map
+      for (auto key : buffer) {
+        auto it = map.find(key);
+        if (it == map.end()) {
+          map.insert({key, 1});
+        } else {
+          it->second++;
+        }
+      }
+      return;
+    }
+
+#ifdef HT_THREAD_POOL
+    pending_jobs = thread_count;
+
+    for (uint32_t i = 0; i < thread_count; i++) {
+      ready[i * CACHELINE_SIZE] = true;
+    }
+
+    // std::cout << "pending jobs: " << pending_jobs << std::endl;
+    mutex_condition.notify_all();
+
+    // std:: cout << "waiting for jobs to finish" << std::endl;
+
+    // busy wait: check if all threads are done
+    while (true) {
+      // std::cout << "pending jobs: " << pending_jobs << std::endl;
+      if (pending_jobs == 0) {
+        break;
+      }
+    }
+#endif
+
+#ifndef HT_THREAD_POOL
+    static_assert(false, "HT_THREAD_POOL is not defined, invalid for map");
+#endif
+  }
+};
+
+template <typename TK, typename Hash = std::hash<TK>,
+          typename KeyEqual = std::equal_to<TK>, uint32_t MAX_THREAD = 16,
+          uint32_t BUFFER_SIZE = 1'000'000>
+class HTMap_Min {
+  using MyType = HTMap_Min<TK, Hash, KeyEqual, MAX_THREAD, BUFFER_SIZE>;
+  using TV = uint32_t;
+
+public:
+  void Start() {}
+
+private:
+#ifdef HT_THREAD_POOL
+  bool should_terminate = false; // Tells threads to stop looking for jobs
+  bool should_gather = false;
+  std::mutex queue_mutex;        // Prevents data races to the job queue
+  std::condition_variable
+      mutex_condition; // Allows threads to wait on new jobs or termination
+  std::vector<std::thread> threads;
+  volatile int pending_jobs = 0; // Number of jobs that have not been completed
+  // avoid false sharing
+
+  std::vector<bool> ready;
+
+  void ThreadLoop(const int id) {
+    auto map_chunk = std::make_unique<hash_map_t>();
+
+    const auto thread_count = MAX_THREAD;
+    auto job = [&]() {
+      const auto set_size = buffer.size() / thread_count;
+      const auto buffer_size = buffer.size();
+
+      auto begin = id * (buffer_size / thread_count);
+      auto end = (id + 1) * (buffer_size / thread_count);
+
+      // for each element in the chunk, insert into the map, and take min
+      for (auto it_buffer = buffer.begin() + begin; it_buffer != buffer.begin() + end; ++it_buffer) {
+        auto &key = it_buffer->first;
+        auto &value = it_buffer->second;
+
+        auto it = map_chunk->find(key);
+        if (it == map_chunk->end()) {
+          map_chunk->insert({key, value});
+        } else {
+          // check and takes the min
+          if (it->second > value) {
+            it->second = value;
+          }
+        }
+      }
+
+      if (should_gather) {
+        m.lock();
+        // std::cout << "thread " << id << " is gathering" << std::endl;
+        // lock the global set and insert the chunk
+        // merge the map_chunk into the global map
+        for (auto it = map_chunk->begin(); it != map_chunk->end(); ++it) {
+          auto global_it = map.find(it->first);
+          if (global_it == map.end()) {
+            map.insert({it->first, it->second});
+          } else {
+            // check and takes the min
+            if (global_it->second > it->second) {
+              global_it->second = it->second;
+            }
+          }
+        }
+        m.unlock();
+        map_chunk->clear();
+      }
+    };
+    while (true) {
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        mutex_condition.wait(lock, [this, id] {
+          return ready[id * CACHELINE_SIZE] || should_terminate;
+        });
+        // std::cout << "Thread " << id << " is running" << std::endl;
+        if (should_terminate) {
+          return;
+        }
+      }
+      job();
+      ready[id * CACHELINE_SIZE] = false;
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        pending_jobs--;
+      }
+    }
+  }
+#endif
+
+private:
+  using buffer_item_t = std::pair<TK, TV>;
+  std::vector<buffer_item_t> buffer;
+  std::mutex m;
+  using hash_map_t = hash_map<TK, TV, Hash, KeyEqual>;
+
+public:
+  hash_map_t map;
+  HTMap_Min() {
+    buffer.reserve(BUFFER_SIZE);
+#ifdef HT_THREAD_POOL
+    const uint32_t num_threads = MAX_THREAD;
+    threads.resize(num_threads);
+
+    ready.resize(num_threads * CACHELINE_SIZE);
+    for (uint32_t i = 0; i < num_threads; i++) {
+      threads[i] = std::thread(&HTMap_Min::ThreadLoop, this, i);
+      ready[i * CACHELINE_SIZE] = false;
+      // threads.at(i) = std::thread(ThreadLoop, i);
+    }
+#endif
+  }
+
+  ~HTMap_Min() {
+#ifdef HT_THREAD_POOL
+    should_terminate = true;
+    mutex_condition.notify_all();
+    for (auto &thread : threads) {
+      thread.join();
+    }
+#endif
+  }
+
+  void emplace_back(buffer_item_t &&t) {
+#ifdef HT
+    buffer.emplace_back(std::move(t));
+    checkBuffer();
+#else
+    set.emplace(std::move(t));
+#endif
+  }
+
+  size_t size() {
+    convertVectorToSet(true);
+    return map.size();
+  }
+
+  void emplace_back(const buffer_item_t &t) {
+#ifdef HT
+    buffer.emplace_back(t);
+    checkBuffer();
+#else
+    set.emplace(t);
+#endif
+  }
+
+  void emplace(buffer_item_t &&t) { emplace_back(t); }
+
+  // the same as emplace_back
+  void emplace(const buffer_item_t &t) { emplace_back(t); }
+
+  // iterator begin
+  auto begin() {
+    convertVectorToSet(true);
+    return map.begin();
+  }
+
+  // iterator end
+  auto end() {
+    convertVectorToSet(true);
+    return map.end();
+  }
+
+  auto count(const TK &key) {
+    convertVectorToSet(true);
+    return map.count(key);
+  }
+
+  // provide [] operator
+  auto &operator[](const TK &key) {
+    convertVectorToSet(true);
+    return map[key];
+  }
+
+  void merge(MyType &other) {
+    merge(other.begin(), other.end());
+  }
+
+  // insert (begin, end)
+  void merge(typename hash_map_t::iterator begin, typename hash_map_t::iterator end) {
+    convertVectorToSet(true);
+    for (auto it = begin; it != end; ++it) {
+      auto global_it = map.find(it->first);
+      if (global_it == map.end()) {
+        map.insert({it->first, it->second});
+      } else {
+        // check and takes the min
+        if (global_it->second > it->second) {
+          global_it->second = it->second;
+        }
+      }
+    }
+  }
+
+private:
+  const uint32_t getThreadCount() {
+#ifdef ADAPTIVE_HT
+    // TODO: adaptive thread count, measure the performance benefit of this
+    // get current active number of threads from /proc/loadavg
+    std::ifstream loadavg("/proc/loadavg");
+
+    // get active threads count
+    // ignore the first three fp numbers, find the 4th int number (before "/")
+    std::string load;
+    for (int i = 0; i < 3; i++) {
+      loadavg >> load;
+    }
+    loadavg >> load;
+    loadavg.close();
+    load = load.substr(0, load.find('/'));
+    int active_threads = std::stoi(load);
+
+    uint32_t MAX_CORES = 56;
+
+    int running_threads = MAX_CORES - active_threads;
+    // max(1, running_threads)
+    running_threads = running_threads > 0 ? running_threads : 1;
+    // min(MAX_THREAD, running_threads)
+    running_threads =
+        running_threads < MAX_THREAD ? running_threads : MAX_THREAD;
+
+    // std::cout << "active threads: " << running_threads << std::endl;
+
+    return running_threads;
+#else
+    return MAX_THREAD;
+#endif
+  }
+
+  inline void checkBuffer() {
+    if (buffer.size() == BUFFER_SIZE) {
+      convertVectorToSet();
+      buffer.resize(0);
+      buffer.reserve(BUFFER_SIZE);
+    }
+  }
+
+  void convertVectorToSet(bool gather = false) {
+    const uint32_t thread_count = getThreadCount();
+    const auto set_size = buffer.size() / thread_count;
+    const auto buffer_size = buffer.size();
+
+    if (buffer_size == 0) {
+      return;
+    }
+
+    if (thread_count == 1) {
+      // merge the buffer to the map
+      for (auto p: buffer) {
+        auto &key = p.first;
+        auto &value = p.second;
+        auto it = map.find(key);
+
+        if (it == map.end()) {
+          map.insert({key, value});
+        } else {
+          // check and takes the min
+          if (it->second > value) {
+            it->second = value;
+          }
+        }
+      }
+      return;
+    }
+
+#ifdef HT_THREAD_POOL
+    pending_jobs = thread_count;
+
+    for (uint32_t i = 0; i < thread_count; i++) {
+      ready[i * CACHELINE_SIZE] = true;
+    }
+
+    // std::cout << "pending jobs: " << pending_jobs << std::endl;
+    if (gather) {
+      should_gather = true;
+    }
+    mutex_condition.notify_all();
+
+    // std:: cout << "waiting for jobs to finish" << std::endl;
+
+    // busy wait: check if all threads are done
+    while (true) {
+      // std::cout << "pending jobs: " << pending_jobs << std::endl;
+      if (pending_jobs == 0) {
+        break;
+      }
+    }
+    should_gather = false;
+#endif
+
+#ifndef HT_THREAD_POOL
+    static_assert(false, "HT_THREAD_POOL is not defined, invalid for map");
+#endif
+  }
+};
+
+template <typename TK, typename Hash = std::hash<TK>,
+          typename KeyEqual = std::equal_to<TK>, uint32_t MAX_THREAD = 16,
+          uint32_t BUFFER_SIZE = 1'000'000>
+class HTMap_IsConstant {
+  using MyType = HTMap_IsConstant<TK, Hash, KeyEqual, MAX_THREAD, BUFFER_SIZE>;
+  using TV = uint64_t;
+
+public:
+  constexpr static TV MAGIC_UNITIALIZED = 0xdeadbeefdeadbeef;
+  constexpr static TV MAGIC_INVALID = 0xbeefdeadbeefdead;
+  void Start() {}
+
+private:
+#ifdef HT_THREAD_POOL
+  bool should_terminate = false; // Tells threads to stop looking for jobs
+  bool should_gather = false;
+  std::mutex queue_mutex;        // Prevents data races to the job queue
+  std::condition_variable
+      mutex_condition; // Allows threads to wait on new jobs or termination
+  std::vector<std::thread> threads;
+  volatile int pending_jobs = 0; // Number of jobs that have not been completed
+  // avoid false sharing
+
+  std::vector<bool> ready;
+
+  void ThreadLoop(const int id) {
+    auto map_chunk = std::make_unique<hash_map_t>();
+
+    const auto thread_count = MAX_THREAD;
+    auto job = [&]() {
+      const auto set_size = buffer.size() / thread_count;
+      const auto buffer_size = buffer.size();
+
+      auto begin = id * (buffer_size / thread_count);
+      auto end = (id + 1) * (buffer_size / thread_count);
+
+      // for each element in the chunk, insert into the map, and set invalid if not same
+      for (auto it_buffer = buffer.begin() + begin; it_buffer != buffer.begin() + end; ++it_buffer) {
+        auto &key = it_buffer->first;
+        auto &value = it_buffer->second;
+
+        auto it = map_chunk->find(key);
+        if (it == map_chunk->end()) {
+          map_chunk->insert({key, value});
+        } else {
+          // check if value is the same
+          if (it->second != MAGIC_INVALID && it->second != value) {
+            it->second = MAGIC_INVALID;
+          }
+        }
+      }
+
+      if (should_gather) {
+        m.lock();
+        // std::cout << "thread " << id << " is gathering" << std::endl;
+        // lock the global set and insert the chunk
+        // merge the map_chunk into the global map
+        for (auto it = map_chunk->begin(); it != map_chunk->end(); ++it) {
+          auto global_it = map.find(it->first);
+          if (global_it == map.end()) {
+            map.insert({it->first, it->second});
+          } else {
+            // check if value is the same
+            if (global_it->second != MAGIC_INVALID && global_it->second != it->second) {
+              global_it->second = MAGIC_INVALID;
+            }
+          }
+        }
+        m.unlock();
+        map_chunk->clear();
+      }
+    };
+    while (true) {
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        mutex_condition.wait(lock, [this, id] {
+          return ready[id * CACHELINE_SIZE] || should_terminate;
+        });
+        // std::cout << "Thread " << id << " is running" << std::endl;
+        if (should_terminate) {
+          return;
+        }
+      }
+      job();
+      ready[id * CACHELINE_SIZE] = false;
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        pending_jobs--;
+      }
+    }
+  }
+#endif
+
+private:
+  using buffer_item_t = std::pair<TK, TV>;
+  std::vector<buffer_item_t> buffer;
+  std::mutex m;
+  using hash_map_t = hash_map<TK, TV, Hash, KeyEqual>;
+
+public:
+  hash_map_t map;
+  HTMap_IsConstant() {
+    buffer.reserve(BUFFER_SIZE);
+#ifdef HT_THREAD_POOL
+    const uint32_t num_threads = MAX_THREAD;
+    threads.resize(num_threads);
+
+    ready.resize(num_threads * CACHELINE_SIZE);
+    for (uint32_t i = 0; i < num_threads; i++) {
+      threads[i] = std::thread(&HTMap_IsConstant::ThreadLoop, this, i);
+      ready[i * CACHELINE_SIZE] = false;
+      // threads.at(i) = std::thread(ThreadLoop, i);
+    }
+#endif
+  }
+
+  ~HTMap_IsConstant() {
+#ifdef HT_THREAD_POOL
+    should_terminate = true;
+    mutex_condition.notify_all();
+    for (auto &thread : threads) {
+      thread.join();
+    }
+#endif
+  }
+
+  void emplace_back(buffer_item_t &&t) {
+#ifdef HT
+    buffer.emplace_back(std::move(t));
+    checkBuffer();
+#else
+    set.emplace(std::move(t));
+#endif
+  }
+
+  size_t size() {
+    convertVectorToSet(true);
+    return map.size();
+  }
+
+  void emplace_back(const buffer_item_t &t) {
+#ifdef HT
+    buffer.emplace_back(t);
+    checkBuffer();
+#else
+    set.emplace(t);
+#endif
+  }
+
+  void emplace(buffer_item_t &&t) { emplace_back(t); }
+
+  // the same as emplace_back
+  void emplace(const buffer_item_t &t) { emplace_back(t); }
+
+  // iterator begin
+  auto begin() {
+    convertVectorToSet(true);
+    return map.begin();
+  }
+
+  // iterator end
+  auto end() {
+    convertVectorToSet(true);
+    return map.end();
+  }
+
+  auto count(const TK &key) {
+    convertVectorToSet(true);
+    return map.count(key);
+  }
+
+  // provide [] operator
+  auto &operator[](const TK &key) {
+    convertVectorToSet(true);
+    return map[key];
+  }
+
+  void merge(MyType &other) {
+    merge(other.begin(), other.end());
+  }
+
+  // insert (begin, end)
+  void merge(typename hash_map_t::iterator begin, typename hash_map_t::iterator end) {
+    convertVectorToSet(true);
+    for (auto it = begin; it != end; ++it) {
+      auto global_it = map.find(it->first);
+      if (global_it == map.end()) {
+        map.insert({it->first, it->second});
+      } else {
+        // check if value is the same
+        if (global_it->second != MAGIC_INVALID && global_it->second != it->second) {
+          global_it->second = MAGIC_INVALID;
+        }
+      }
+    }
+  }
+
+private:
+  const uint32_t getThreadCount() {
+#ifdef ADAPTIVE_HT
+    // TODO: adaptive thread count, measure the performance benefit of this
+    // get current active number of threads from /proc/loadavg
+    std::ifstream loadavg("/proc/loadavg");
+
+    // get active threads count
+    // ignore the first three fp numbers, find the 4th int number (before "/")
+    std::string load;
+    for (int i = 0; i < 3; i++) {
+      loadavg >> load;
+    }
+    loadavg >> load;
+    loadavg.close();
+    load = load.substr(0, load.find('/'));
+    int active_threads = std::stoi(load);
+
+    uint32_t MAX_CORES = 56;
+
+    int running_threads = MAX_CORES - active_threads;
+    // max(1, running_threads)
+    running_threads = running_threads > 0 ? running_threads : 1;
+    // min(MAX_THREAD, running_threads)
+    running_threads =
+        running_threads < MAX_THREAD ? running_threads : MAX_THREAD;
+
+    // std::cout << "active threads: " << running_threads << std::endl;
+
+    return running_threads;
+#else
+    return MAX_THREAD;
+#endif
+  }
+
+  inline void checkBuffer() {
+    if (buffer.size() == BUFFER_SIZE) {
+      convertVectorToSet();
+      buffer.resize(0);
+      buffer.reserve(BUFFER_SIZE);
+    }
+  }
+
+  void convertVectorToSet(bool gather = false) {
+    const uint32_t thread_count = getThreadCount();
+    const auto set_size = buffer.size() / thread_count;
+    const auto buffer_size = buffer.size();
+
+    if (buffer_size == 0) {
+      return;
+    }
+
+    if (thread_count == 1) {
+      // merge the buffer to the map
+      for (auto p: buffer) {
+        auto &key = p.first;
+        auto &value = p.second;
+        auto it = map.find(key);
+
+        if (it == map.end()) {
+          map.insert({key, value});
+        } else {
+          // check if value is the same
+          if (it->second != MAGIC_INVALID && it->second != value) {
+            it->second = MAGIC_INVALID;
+          }
+        }
+      }
+      return;
+    }
+
+#ifdef HT_THREAD_POOL
+    pending_jobs = thread_count;
+
+    for (uint32_t i = 0; i < thread_count; i++) {
+      ready[i * CACHELINE_SIZE] = true;
+    }
+
+    // std::cout << "pending jobs: " << pending_jobs << std::endl;
+    if (gather) {
+      should_gather = true;
+    }
+    mutex_condition.notify_all();
+
+    // std:: cout << "waiting for jobs to finish" << std::endl;
+
+    // busy wait: check if all threads are done
+    while (true) {
+      // std::cout << "pending jobs: " << pending_jobs << std::endl;
+      if (pending_jobs == 0) {
+        break;
+      }
+    }
+    should_gather = false;
+#endif
+
+#ifndef HT_THREAD_POOL
+    static_assert(false, "HT_THREAD_POOL is not defined, invalid for map");
+#endif
+  }
+};
+
+template <typename TK, typename TV, typename Hash = std::hash<TK>,
+          typename KeyEqual = std::equal_to<TK>, uint32_t MAX_THREAD = 16,
+          uint32_t BUFFER_SIZE = 1'000'000>
+class HTMap_Set {
+  using MyType = HTMap_Set<TK, TV, Hash, KeyEqual, MAX_THREAD, BUFFER_SIZE>;
+
+public:
+  void Start() {}
+
+private:
+#ifdef HT_THREAD_POOL
+  bool should_terminate = false; // Tells threads to stop looking for jobs
+  bool should_gather = false;
+  std::mutex queue_mutex;        // Prevents data races to the job queue
+  std::condition_variable
+      mutex_condition; // Allows threads to wait on new jobs or termination
+  std::vector<std::thread> threads;
+  volatile int pending_jobs = 0; // Number of jobs that have not been completed
+  // avoid false sharing
+
+  std::vector<bool> ready;
+
+  void ThreadLoop(const int id) {
+    auto map_chunk = std::make_unique<hash_map_t>();
+
+    const auto thread_count = MAX_THREAD;
+    auto job = [&]() {
+      const auto set_size = buffer.size() / thread_count;
+      const auto buffer_size = buffer.size();
+
+      auto begin = id * (buffer_size / thread_count);
+      auto end = (id + 1) * (buffer_size / thread_count);
+
+      // for each element in the chunk, insert into the map, and set invalid if not same
+      for (auto it = buffer.begin() + begin; it != buffer.begin() + end; ++it) {
+        auto &key = it->first;
+        auto &value = it->second;
+
+        auto it_chunk = map_chunk->find(key);
+
+        if (it_chunk == map_chunk->end()) {
+          // insert a new set as value
+          hash_set<TV> set = {value};
+          map_chunk->insert({key, set});
+        } else {
+          // check if value is the same
+          map_chunk->at(key).insert(value);
+        }
+      }
+
+      if (should_gather) {
+        m.lock();
+        // lock the global set and insert the chunk
+        // merge the map_chunk into the global map
+        for (auto it = map_chunk->begin(); it != map_chunk->end(); ++it) {
+          auto global_it = map.find(it->first);
+          if (global_it == map.end()) {
+            map.insert({it->first, it->second});
+          } else {
+            // check if value is the same
+            global_it->second.insert(it->second.begin(), it->second.end());
+          }
+        }
+        m.unlock();
+        map_chunk->clear();
+      }
+    };
+    while (true) {
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        mutex_condition.wait(lock, [this, id] {
+          return ready[id * CACHELINE_SIZE] || should_terminate;
+        });
+        // std::cout << "Thread " << id << " is running" << std::endl;
+        if (should_terminate) {
+          return;
+        }
+      }
+      job();
+      ready[id * CACHELINE_SIZE] = false;
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        pending_jobs--;
+      }
+    }
+  }
+#endif
+
+private:
+  using buffer_item_t = std::pair<TK, TV>;
+  std::vector<buffer_item_t> buffer;
+  std::mutex m;
+  using hash_map_t = hash_map<TK, hash_set<TV>, Hash, KeyEqual>;
+
+public:
+  hash_map_t map;
+  HTMap_Set() {
+    buffer.reserve(BUFFER_SIZE);
+#ifdef HT_THREAD_POOL
+    const uint32_t num_threads = MAX_THREAD;
+    threads.resize(num_threads);
+
+    ready.resize(num_threads * CACHELINE_SIZE);
+    for (uint32_t i = 0; i < num_threads; i++) {
+      threads[i] = std::thread(&HTMap_Set::ThreadLoop, this, i);
+      ready[i * CACHELINE_SIZE] = false;
+      // threads.at(i) = std::thread(ThreadLoop, i);
+    }
+#endif
+  }
+
+  ~HTMap_Set() {
+#ifdef HT_THREAD_POOL
+    should_terminate = true;
+    mutex_condition.notify_all();
+    for (auto &thread : threads) {
+      thread.join();
+    }
+#endif
+  }
+
+  void emplace_back(buffer_item_t &&t) {
+#ifdef HT
+    buffer.emplace_back(std::move(t));
+    checkBuffer();
+#else
+    set.emplace(std::move(t));
+#endif
+  }
+
+  void emplace_back(const buffer_item_t &t) {
+#ifdef HT
+    buffer.emplace_back(t);
+    checkBuffer();
+#else
+    set.emplace(t);
+#endif
+  }
+
+  void emplace(buffer_item_t &&t) { emplace_back(t); }
+
+  // the same as emplace_back
+  void emplace(const buffer_item_t &t) { emplace_back(t); }
+
+  // iterator begin
+  auto begin() {
+    convertVectorToSet(true);
+    return map.begin();
+  }
+
+  // iterator end
+  auto end() {
+    convertVectorToSet(true);
+    return map.end();
+  }
+
+  auto count(const TK &key) {
+    convertVectorToSet(true);
+    return map.count(key);
+  }
+
+  // provide [] operator
+  auto &operator[](const TK &key) {
+    convertVectorToSet(true);
+    return map[key];
+  }
+
+  void merge(MyType &other) {
+    merge(other.begin(), other.end());
+  }
+
+  // insert (begin, end)
+  void merge(typename hash_map_t::iterator begin, typename hash_map_t::iterator end) {
+    convertVectorToSet(true);
+    for (auto it = begin; it != end; ++it) {
+      // if the key is not in the map, insert it
+      auto global_it = map.find(it->first);
+      if (global_it == map.end()) {
+        map.insert({it->first, it->second});
+      } else {
+        // merge the set
+        global_it->second.merge(it->second);
+      }
+    }
+  }
+
+private:
+  const uint32_t getThreadCount() {
+#ifdef ADAPTIVE_HT
+    // TODO: adaptive thread count, measure the performance benefit of this
+    // get current active number of threads from /proc/loadavg
+    std::ifstream loadavg("/proc/loadavg");
+
+    // get active threads count
+    // ignore the first three fp numbers, find the 4th int number (before "/")
+    std::string load;
+    for (int i = 0; i < 3; i++) {
+      loadavg >> load;
+    }
+    loadavg >> load;
+    loadavg.close();
+    load = load.substr(0, load.find('/'));
+    int active_threads = std::stoi(load);
+
+    uint32_t MAX_CORES = 56;
+
+    int running_threads = MAX_CORES - active_threads;
+    // max(1, running_threads)
+    running_threads = running_threads > 0 ? running_threads : 1;
+    // min(MAX_THREAD, running_threads)
+    running_threads =
+        running_threads < MAX_THREAD ? running_threads : MAX_THREAD;
+
+    // std::cout << "active threads: " << running_threads << std::endl;
+
+    return running_threads;
+#else
+    return MAX_THREAD;
+#endif
+  }
+
+  inline void checkBuffer() {
+    if (buffer.size() == BUFFER_SIZE) {
+      convertVectorToSet();
+      buffer.resize(0);
+      buffer.reserve(BUFFER_SIZE);
+    }
+  }
+
+  void convertVectorToSet(bool gather = false) {
+    const uint32_t thread_count = getThreadCount();
+    const auto set_size = buffer.size() / thread_count;
+    const auto buffer_size = buffer.size();
+
+    if (buffer_size == 0) {
+      return;
+    }
+
+    if (thread_count == 1) {
+      // merge the buffer to the map
+      for (auto p: buffer) {
+        auto &key = p.first;
+        auto &value = p.second;
+
+        auto global_it = map.find(key);
+        if (global_it == map.end()) {
+          hash_set<TV> set = {value};
+          map.insert({key, set});
+        } else {
+          global_it->second.insert(value);
+        }
+      }
+      return;
+    }
+
+#ifdef HT_THREAD_POOL
+    pending_jobs = thread_count;
+
+    for (uint32_t i = 0; i < thread_count; i++) {
+      ready[i * CACHELINE_SIZE] = true;
+    }
+
+    if (gather) {
+      should_gather = true;
+    }
+    // std::cout << "pending jobs: " << pending_jobs << std::endl;
+    mutex_condition.notify_all();
+
+    // std:: cout << "waiting for jobs to finish" << std::endl;
+
+    // busy wait: check if all threads are done
+    while (true) {
+      // std::cout << "pending jobs: " << pending_jobs << std::endl;
+      if (pending_jobs == 0) {
+        break;
+      }
+    }
+    should_gather = false;
+#endif
+
+#ifndef HT_THREAD_POOL
+    static_assert(false, "HT_THREAD_POOL is not defined, invalid for map");
+#endif
+  }
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.cpp b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.cpp
new file mode 100644
index 00000000..2457224e
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.cpp
@@ -0,0 +1,62 @@
+#include "LoadedValueModule.h"
+#include <utility>
+
+void LoadedValueModule::init(uint32_t loop_id, uint32_t pid) {
+}
+
+void LoadedValueModule::fini(const char *filename) {
+  std::ofstream specprivfs(filename);
+  specprivfs << "BEGIN SPEC PRIV PROFILE\n";
+  for (auto &[key, cp] : constmap_value) {
+    if (cp != constmap_value.MAGIC_INVALID) {
+      // instr and value
+      auto instr = key.first;
+      // auto value = cp->value;
+      auto value = cp;
+      // later, we need to parse the instruction to see if it's a pointer or a
+      // regular integer
+      specprivfs << "PRED VAL " << instr << " " << value << " ; \n";
+    }
+  }
+
+  specprivfs << " END SPEC PRIV PROFILE\n";
+  specprivfs.close();
+}
+
+void LoadedValueModule::load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value, uint8_t size) {
+  local_write(instr, [&]() {
+    AccessKey key(instr, bare_instr);
+    constmap_value.emplace(std::make_pair(key, value));
+  });
+  // if (constmap_value.count(key) != 0) {
+  // auto cp = constmap_value[key];
+
+  // if (cp->valid) {
+  // if (cp->value != value) {
+  // cp->valid = false;
+  // }
+  // }
+  // // // Remove check for constant need to have the same address
+  // // if (cp->valueinit && cp->addr != addr)
+  // //   cp->valid = false;
+  // // if (cp->valid) {
+  // //   if (cp->valueinit && cp->value != value) {
+  // //     cp->valid = false;
+  // //   }
+  // //   else {
+  // //     cp->valueinit = true;
+  // //     cp->value = value;
+  // //     cp->addr = addr;
+  // //   }
+  // // }
+  // } else {
+    // auto cp = new Constant(true, value);
+    // constmap_value[key] = cp;
+    // // auto cp = new Constant(true, true, size, addr, value);
+    // // constmap_value->insert(std::make_pair(key, cp));
+  // }
+}
+
+void LoadedValueModule::merge_values(LoadedValueModule &other) {
+  constmap_value.merge(other.constmap_value);
+}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.h
new file mode 100644
index 00000000..4c8d7331
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LoadedValueModule.h
@@ -0,0 +1,67 @@
+#pragma once
+#include <cstdint>
+#include <unordered_set>
+#include <vector>
+
+#include "LocalWriteModule.h"
+#include "HTContainer.h"
+#include "context.h"
+
+enum class LoadedValueModAction : uint32_t {
+  INIT = 0,
+  LOAD,
+  FINISHED
+};
+
+struct PairHash
+{
+    std::size_t operator () (std::pair<uint32_t, uint32_t> const &v) const
+    {
+      static_assert(sizeof(size_t) == sizeof(uint64_t), "Should be 64bit address");
+      // std::hash<uint32_t> hash_fn;
+      // need to make sure if the pair are the same, this doesn't generate 0
+      return ((uint64_t)v.first << 32) | v.second;
+    }
+};
+
+// instr, bare_instr
+using AccessKey = std::pair<uint32_t, uint32_t>;
+struct Constant {
+  bool valid;
+  // bool valueinit;
+  // uint8_t size;
+  // uint64_t addr;
+  uint64_t value;
+  // char pad[64 - sizeof(uint64_t) - sizeof(uint64_t) - sizeof(uint8_t) -
+  //          sizeof(bool) - sizeof(bool)];
+
+  Constant(bool valid, uint64_t value) : valid(valid), value(value) {}
+  // Constant(bool va, bool vi, uint8_t s, uint64_t a, uint64_t v)
+  //     : valid(va), valueinit(vi), size(s), addr(a), value(v) {}
+};
+
+
+class LoadedValueModule: public GenericLocalWriteModule {
+  private:
+    uint64_t slamp_iteration = 0;
+    uint64_t slamp_invocation = 0;
+    uint32_t target_loop_id = 0;
+
+    bool in_loop = false;
+
+    // std::unordered_map<AccessKey, Constant *, PairHash> *constmap_value;
+    HTMap_IsConstant<AccessKey, PairHash>  constmap_value;
+
+  public:
+    LoadedValueModule(uint32_t mask, uint32_t pattern)
+      : GenericLocalWriteModule(mask, pattern) {
+  }
+ 
+  ~LoadedValueModule() override = default;
+
+  void init(uint32_t loop_id, uint32_t pid);
+  void fini(const char *filename);
+  void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value, uint8_t size);
+
+  void merge_values(LoadedValueModule &other);
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LocalWriteModule.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LocalWriteModule.h
new file mode 100644
index 00000000..e41febf9
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/LocalWriteModule.h
@@ -0,0 +1,47 @@
+#pragma once
+#include <cstdint>
+
+class LocalWriteModule {
+protected:
+  const uint32_t LOCALWRITE_MASK{};
+  const uint32_t LOCALWRITE_PATTERN{};
+  // PAGE SIZE 4096 = 2^12; FIXME: here we can make it finer because we
+  // allocate 8 bytes of metadata per one byte of data, but changes to
+  // shadow memory needed
+  static constexpr uint32_t LOCALWRITE_SHIFT = 12;
+  // takes in a lambda action and uint64_t addr
+  template <typename F>
+  inline void local_write(uint64_t addr, const F &action) {
+    if (((addr >> LOCALWRITE_SHIFT) & LOCALWRITE_MASK) == LOCALWRITE_PATTERN) {
+      action();
+    }
+  }
+
+public:
+  LocalWriteModule(uint32_t mask, uint32_t pattern)
+      : LOCALWRITE_MASK(mask), LOCALWRITE_PATTERN(pattern) {}
+  virtual ~LocalWriteModule() = default;
+};
+
+class GenericLocalWriteModule {
+protected:
+  const uint32_t LOCALWRITE_MASK{};
+  const uint32_t LOCALWRITE_PATTERN{};
+  // PAGE SIZE 4096 = 2^12; FIXME: here we can make it finer because we
+  // allocate 8 bytes of metadata per one byte of data, but changes to
+  // shadow memory needed
+  static constexpr uint32_t LOCALWRITE_SHIFT = 0;
+  // takes in a lambda action and uint64_t addr
+  template <typename F>
+  inline void local_write(uint64_t value, const F &action) {
+    if (((value >> LOCALWRITE_SHIFT) & LOCALWRITE_MASK) == LOCALWRITE_PATTERN) {
+      action();
+    }
+  }
+
+public:
+  GenericLocalWriteModule(uint32_t mask, uint32_t pattern)
+      : LOCALWRITE_MASK(mask), LOCALWRITE_PATTERN(pattern) {}
+  virtual ~GenericLocalWriteModule() = default;
+};
+
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.cpp b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.cpp
new file mode 100644
index 00000000..9444a727
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.cpp
@@ -0,0 +1,105 @@
+#include "ObjectLifetimeModule.h"
+#include "slamp_timestamp.h"
+
+void ObjectLifetimeModule::allocate(void *addr, uint32_t instr, uint64_t size) {
+  void* shadow = smmap->allocate(addr, size);
+
+  TS *s = (TS *)shadow;
+  // log all data into sigle TS
+  // FIXME: static instruction and the dynamic context?
+  // context: static instr + function + loop
+  auto hash = contextManager.encodeActiveContext();
+  // print active context
+  // contextManager->activeContext->print(std::cerr);
+
+  // currentContext->print(std::cerr);
+  // std::cerr << "malloc hash: " << hash << "\n";
+
+  // TS ts = CREATE_TS(instr, hash, __slamp_invocation);
+  TS ts = CREATE_TS_HASH(instr, hash, slamp_iteration, slamp_iteration);
+
+  //8 bytes per byte TODO: can we reduce this?
+  for (auto i = 0; i < size; i++)
+    s[i] = ts;
+}
+
+void ObjectLifetimeModule::free(void *addr) {
+  local_write((uint64_t)addr, [&](){
+    if (addr == nullptr)
+      return;
+    // if we are still in the loop and the iteration is the same, mark it as
+    // local otherwise mark it as not local
+    TS *s = (TS *)GET_SHADOW_OL(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+    // auto instr = GET_INSTR(s[0]);
+    // auto hash = GET_HASH(s[0]);
+    auto iteration = GET_INVOC(s[0]) & 0xF0 >> 4;
+    auto invocation = GET_INVOC(s[0]) & 0xF;
+
+    auto instrAndHash = s[0] & 0xFFFFFFFFFFFFFF00;
+
+    if (iteration == (0xf & slamp_iteration) &&
+        invocation == (0xf & slamp_invocation) && in_loop == true) {
+      shortLivedObjects.emplace(instrAndHash);
+    } else {
+      // is not short-lived
+      longLivedObjects.emplace(instrAndHash);
+    }
+  });
+}
+
+// manage context
+void ObjectLifetimeModule::func_entry(uint32_t fcnId) {
+  auto contextId = ContextId(FunctionContext, fcnId);
+  contextManager.pushContext(contextId);
+}
+
+void ObjectLifetimeModule::func_exit(uint32_t fcnId) {
+  auto contextId = ContextId(FunctionContext, fcnId);
+  contextManager.popContext(contextId);
+}
+
+
+void ObjectLifetimeModule::loop_invoc() {
+  slamp_iteration = 0;
+  slamp_invocation++;
+  in_loop = true;
+}
+
+void ObjectLifetimeModule::loop_iter() { slamp_iteration++; }
+
+void ObjectLifetimeModule::loop_exit() {
+  in_loop = false;
+}
+
+
+void ObjectLifetimeModule::init(uint32_t loop_id, uint32_t pid) {
+  target_loop_id = loop_id;
+#define SIZE_8M  0x800000
+  smmap->init_stack(SIZE_8M, pid);
+}
+
+// TODO: implement dumping
+void ObjectLifetimeModule::fini(const char *filename) {
+  // Dump compatible one as SpecPriv output
+  std::ofstream specprivfs(filename);
+  specprivfs << "BEGIN SPEC PRIV PROFILE\n";
+  specprivfs << "COMPLETE ALLOCATION INFO ; \n";
+
+  // local objects
+  for (auto &obj : shortLivedObjects) {
+    // LOCAL OBJECT AU HEAP main if.else.i call.i4.i FROM  CONTEXT { LOOP main
+    // for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  IS LOCAL TO  CONTEXT {
+    // LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  COUNT 300 ;
+    if (longLivedObjects.count(obj))
+      continue;
+
+    auto instr = GET_INSTR(obj);
+    auto hash = GET_HASH(obj);
+    specprivfs << "LOCAL OBJECT " << instr << " at context ";
+    contextManager.printContext(specprivfs, hash);
+    specprivfs << ";\n";
+  }
+
+  specprivfs << " END SPEC PRIV PROFILE\n";
+}
+
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.h
new file mode 100644
index 00000000..08cd2cbf
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/ObjectLifetimeModule.h
@@ -0,0 +1,75 @@
+#include <cstdint>
+#include <unordered_set>
+#include <vector>
+
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "slamp_timestamp.h"
+
+#include "LocalWriteModule.h"
+#include "HTContainer.h"
+#include "ContextManager.h"
+
+enum class ObjectLifetimeModAction : uint32_t {
+  INIT = 0,
+  // LOAD,
+  // STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_EXIT,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  FINISHED
+};
+
+// using namespace SLAMPLib;
+
+class ObjectLifetimeModule: public LocalWriteModule {
+  private:
+    uint64_t slamp_iteration = 0;
+    uint64_t slamp_invocation = 0;
+    slamp::MemoryMap<MASK2_OL> *smmap = nullptr;
+    uint32_t target_loop_id = 0;
+
+    bool in_loop = false;
+
+
+    enum SpecPrivContextType {
+      TopContext = 0,
+      FunctionContext,
+      LoopContext,
+    };
+
+    using SpecPrivContextManager = NewContextManager<SpecPrivContextType, uint32_t, uint64_t>;
+    using ContextId = ContextId<SpecPrivContextType, uint32_t>;
+    SpecPrivContextManager contextManager;
+
+    HTSet<uint64_t, std::hash<uint64_t>, std::equal_to<>, 16> shortLivedObjects, longLivedObjects;
+    // std::unordered_set<unsigned long> shortLivedObjects, longLivedObjects;
+
+  public:
+  ObjectLifetimeModule(uint32_t mask, uint32_t pattern)
+      : LocalWriteModule(mask, pattern) {
+    smmap = new slamp::MemoryMap<MASK2_OL>(LOCALWRITE_MASK, LOCALWRITE_PATTERN, TIMESTAMP_SIZE_IN_BYTES);
+  }
+
+  ~ObjectLifetimeModule() override {
+    delete smmap;
+  }
+
+  void init(uint32_t loop_id, uint32_t pid);
+  void fini(const char *filename);
+
+  void allocate(void *addr, uint32_t instr, uint64_t size);
+  void free(void *addr);
+
+  void func_entry(uint32_t fcnId);
+  void func_exit(uint32_t fcnId);
+
+  void loop_invoc();
+  void loop_iter();
+  void loop_exit();
+
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.cpp b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.cpp
new file mode 100644
index 00000000..423870e2
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.cpp
@@ -0,0 +1,365 @@
+#include "PointsToModule.h"
+#include "context.h"
+#include "slamp_timestamp.h"
+#include <utility>
+
+// Points-to module
+// Requires events:
+//  - Stack alloca
+//  - Stack free?
+//  - [x] Head allocation and free
+//  - [x] Target loop invocation, iteration
+//  - [x] Loop entry, exit
+//  - [x] Fcn entry, exit
+//  - Report base
+//  - init, fini
+#define  FORMAT_INST_ARG(fcnId, argId) (fcnId << 5 | (0x1f & (argId  << 4) | 0x1))
+#define FORMAT_INST_INST(instId) (instId << 1 | 0x0)
+
+bool in_func5 = false;
+
+void PointsToModule::allocate(void *addr, uint32_t instr, uint64_t size) {
+  // FIXME: is it leagal
+  void* shadow = smmap->allocate(addr, size + 1);
+  // void* shadow = smmap->allocate(addr, size);
+
+  TS *s = (TS *)shadow;
+  // log all data into sigle TS
+  // FIXME: static instruction and the dynamic context?
+  // context: static instr + function + loop
+  auto hash = contextManager.encodeActiveContext();
+  // print active context
+  // contextManager->activeContext->print(std::cerr);
+
+  // currentContext->print(std::cerr);
+  // std::cerr << "malloc hash: " << hash << "\n";
+
+  // TS ts = CREATE_TS(instr, hash, __slamp_invocation);
+  TS ts = CREATE_TS_HASH(instr, hash, slamp_iteration, slamp_iteration);
+
+  //8 bytes per byte TODO: can we reduce this?
+  for (auto i = 0; i < size; i++) {
+    // FIXME: make it more compact
+    local_write((uint64_t)addr + i, [&](){
+      s[i] = ts;
+    });
+  }
+
+  // FIXME: is this legal?
+  // Guard the last byte out of the range
+  local_write((uint64_t)addr + size, [&](){
+    s[size] = ts;
+  });
+
+}
+
+void PointsToModule::free(void *addr) {
+}
+
+// manage context
+void PointsToModule::func_entry(uint32_t fcnId) {
+  if (fcnId == 5) {
+    in_func5 = true;
+  }
+
+  auto contextId = ContextId(FunctionContext, fcnId);
+  contextManager.pushContext(contextId);
+}
+
+void PointsToModule::func_exit(uint32_t fcnId) {
+  if (fcnId == 5) {
+    in_func5 = false;
+  }
+  auto contextId = ContextId(FunctionContext, fcnId);
+  contextManager.popContext(contextId);
+}
+
+void PointsToModule::loop_entry(uint32_t loopId) {
+  auto contextId = ContextId(LoopContext, loopId);
+  contextManager.pushContext(contextId);
+
+  if (loopId == target_loop_id) {
+    in_loop = true;
+  }
+}
+
+void PointsToModule::loop_exit(uint32_t loopId) {
+  auto contextId = ContextId(LoopContext, loopId);
+  contextManager.popContext(contextId);
+  if (loopId == target_loop_id) {
+    in_loop = false;
+  }
+}
+
+
+void PointsToModule::loop_invoc() {
+  targetLoopContexts.emplace(contextManager.encodeActiveContext());
+  slamp_iteration = 0;
+  slamp_invocation++;
+}
+
+void PointsToModule::loop_iter() { slamp_iteration++; }
+
+void PointsToModule::points_to_arg(uint32_t fcnId, uint32_t argId, void *ptr) {
+  local_write((uint64_t)ptr, [&]() {
+    auto instr = FORMAT_INST_ARG(fcnId, argId);
+    auto contextHash = contextManager.encodeActiveContext();
+    uint64_t instrAndHash = ((uint64_t)instr << 32) | contextHash;
+    if (ptr == nullptr) {
+      pointsToMap.emplace(std::make_pair(instrAndHash, 0));
+      // pointsToMap[instrAndHash].(0);
+      // pointsToMap.emplace(std::make_pair(instrAndHash, 0));
+      return;
+    }
+    if (ptr < (void *)0x1000) {
+      // Protect against null pointers
+      // If it gets dereferenced, it will be caught by segfault
+      return;
+    }
+    TS *s = (TS *)GET_SHADOW_PT(ptr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+    TS ts;
+    // if (!smmap->is_allocated(ptr))
+    // return;
+    ts = s[0];
+
+    if (ts != 0) {
+      // mask off the iteration count
+      ts = ts & 0xffffffffffffff00;
+      // ts = ts & 0xfffffffffffffff0;
+      // ts = ts & 0xfffff0000000000f;
+      // create set of objects for each load/store
+      pointsToMap.emplace(std::make_pair(instrAndHash, ts));
+      // pointsToMap[instrAndHash].insert(ts);
+      // pointsToMap.emplace(std::make_pair(instrAndHash, ts));
+    }
+  });
+}
+
+void PointsToModule::points_to_inst(uint32_t instId, void *ptr) {
+  local_write((uint64_t)ptr, [&]() {
+    auto instr = FORMAT_INST_INST(instId);
+    auto contextHash = contextManager.encodeActiveContext();
+    uint64_t instrAndHash = ((uint64_t)instr << 32) | contextHash;
+    if (ptr == nullptr) {
+      pointsToMap.emplace(std::make_pair(instrAndHash, 0));
+      // pointsToMap[instrAndHash].insert(0);
+      // pointsToMap.emplace(std::make_pair(instrAndHash, 0));
+      return;
+    }
+    if (ptr < (void *)0x1000) {
+      // Protect against null pointers
+      // If it gets dereferenced, it will be caught by segfault
+      return;
+    }
+    TS *s = (TS *)GET_SHADOW_PT(ptr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+    TS ts;
+
+    // not all pointers are well-defined
+    // if (!smmap->is_allocated(ptr))
+    // return;
+    ts = s[0];
+
+    if (ts != 0) {
+      // mask off the iteration count
+      ts = ts & 0xffffffffffffff00;
+      // ts = ts & 0xfffffffffffffff0;
+      // ts = ts & 0xfffff0000000000f;
+      // create set of objects for each load/store
+      pointsToMap.emplace(std::make_pair(instrAndHash, ts));
+      // pointsToMap[instrAndHash].insert(ts);
+      // pointsToMap.emplace(std::make_pair(instrAndHash, ts));
+    }
+  });
+}
+
+void PointsToModule::init(uint32_t loop_id, uint32_t pid) {
+  target_loop_id = loop_id;
+#define SIZE_8M  0x800000
+  smmap->init_stack(SIZE_8M, pid);
+}
+
+void PointsToModule::fini(const char *filename) {
+  // Dump compatible one as SpecPriv output
+  std::ofstream specprivfs(filename);
+  specprivfs << "BEGIN SPEC PRIV PROFILE\n";
+  specprivfs << "COMPLETE ALLOCATION INFO ; \n";
+
+
+  // print all loop contexts
+  specprivfs << "LOOP CONTEXTS: " << targetLoopContexts.size() << "\n";
+  for (auto contextHash : targetLoopContexts) {
+    contextManager.printContext(specprivfs, contextHash);
+    specprivfs << "\n";
+  }
+
+  // predict OBJ
+  //  PRED OBJ main if.else.i $0 AT  CONTEXT { LOOP main for.cond15 1 WITHIN
+  //  FUNCTION main WITHIN TOP }  AS PREDICTABLE 300 SAMPLES OVER 1 VALUES {  (
+  //  OFFSET 0 BASE AU HEAP allocate_matrices for.end call7 FROM  CONTEXT {
+  //  FUNCTION allocate_matrices WITHIN FUNCTION main WITHIN TOP }  COUNT 300 )
+  //  } ;
+
+  // // get ordered key from the map
+  // std::vector<uint64_t> keys;
+  // for (auto &kv : pointsToMap) {
+  //   keys.push_back(kv.first);
+  // }
+  // std::sort(keys.begin(), keys.end());
+
+  // for (auto &key : keys) {
+  //   auto v = pointsToMap[key];
+  //   auto instr = key  >> 32;
+  //   auto instrHash = key & 0xFFFFFFFF;
+  //   std::vector<SpecPrivLib::ContextId> instrContext =
+  //       contextManager.decodeContext(instrHash);
+  //   specprivfs << "PRED OBJ " << instr << " at " << instrHash << " ";
+  //   printContext(instrContext);
+  //   specprivfs << ": " << v.size() << "\n"; // instruction ID
+  //   for (auto &it2 : v) { // the set of allocation units
+  //     auto hash = GET_HASH(it2);
+
+  //     specprivfs << "AU ";
+  //     if (it2 == 0xffffffffffffff00) {
+  //       specprivfs << " UNMANAGED";
+  //     } else if (it2 == 0) {
+  //       specprivfs << " NULL";
+  //     } else {
+  //       std::vector<SpecPrivLib::ContextId> context =
+  //           contextManager.decodeContext(hash);
+
+  //       specprivfs << GET_INSTR(it2);
+  //       specprivfs << " FROM CONTEXT " << instrHash << " ";
+  //       printContext(context);
+  //     }
+  //     specprivfs << ";\n";
+  //   }
+  // }
+
+  auto printContext = [&](std::vector<ContextId> context) {
+    for (auto it = context.rbegin(); it != context.rend(); it++) {
+      auto &c = *it;
+      c.print(specprivfs);
+    }
+  };
+
+  for (auto &kv : decodedContextMap) {
+    auto ptrAndContext = kv.first;
+    auto instr = ptrAndContext.first;
+    auto context = ptrAndContext.second;
+
+    specprivfs << "PRED OBJ " << instr << " at ";
+    printContext(context);
+    // auto auSet = kv.second;
+    // specprivfs << ": " << auSet.size() << "\n"; // instruction ID
+    // for (auto &[au, context] : auSet) {
+      // specprivfs << "AU ";
+      // if (au == -2) {
+        // specprivfs << " UNMANAGED";
+      // } else if (au == -1) {
+        // specprivfs << " NULL";
+      // } else {
+        // specprivfs << au;
+        // specprivfs << " FROM CONTEXT ";
+        // printContext(context);
+      // }
+      // specprivfs << ";\n";
+    // }
+    specprivfs << ": " << 1 << "\n"; // instruction ID
+    auto au = kv.second.first;
+    auto auContext = kv.second.second;
+    specprivfs << "AU ";
+    if (au == -3) {
+      specprivfs << " NOT CONSTANT";
+    }
+    else if (au == -2) {
+      specprivfs << " UNMANAGED";
+    } else if (au == -1) {
+      specprivfs << " NULL";
+    } else {
+      specprivfs << au;
+      specprivfs << " FROM CONTEXT ";
+      printContext(auContext);
+    }
+    specprivfs << ";\n";
+
+  }
+
+  specprivfs << " END SPEC PRIV PROFILE\n";
+}
+
+void PointsToModule::decode_all() {
+  // convert it to decodedContextMap
+  for (auto &it : pointsToMap) {
+
+    auto instr = it.first  >> 32;
+    auto instrHash = it.first & 0xFFFFFFFF;
+
+    std::vector<ContextId> instrContext =
+        contextManager.decodeContext(instrHash);
+    InstrAndContext instrAndContext = {instr, instrContext};
+
+    SlampAllocationUnit au = it.second;
+    auto hash = GET_HASH(au);
+
+    if (au == HTMap_IsConstant<uint64_t>::MAGIC_INVALID) {
+      // Not constant
+      decodedContextMap[instrAndContext] = {-3, {}};
+    }
+    else if (au == 0xffffffffffffff00) {
+      // unmanaged
+      decodedContextMap[instrAndContext] = {-2, {}};
+    } else if (au == 0) {
+      // null
+      decodedContextMap[instrAndContext] = {-1, {}};
+    } else {
+      std::vector<ContextId> context = contextManager.decodeContext(hash);
+      decodedContextMap[instrAndContext] = {GET_INSTR(au), context};
+    }
+    // for (auto &it2 : it.second) { // the set of allocation units
+      // auto hash = GET_HASH(it2);
+      // if (hash == 0xfffffffff) {
+        // // insert -2, empty
+        // decodedContextMap[instrAndContext].insert({-2, {}});
+      // } else if (hash == 0) {
+        // // insert -1, empty
+        // decodedContextMap[instrAndContext].insert({-1, {}});
+      // } else {
+        // std::vector<ContextId> context =
+            // contextManager.decodeContext(hash);
+        // decodedContextMap[instrAndContext].insert({GET_INSTR(it2), context});
+      // }
+    // }
+
+
+  }
+}
+
+void PointsToModule::merge(PointsToModule &other) {
+  other.decode_all();
+
+  for (auto &it : other.decodedContextMap) {
+    auto instrAndContext = it.first;
+    if (decodedContextMap.find(instrAndContext) == decodedContextMap.end()) {
+      // not found, insert
+      decodedContextMap[instrAndContext] = it.second;
+    } else {
+      // found, if different, set to unmanaged
+      if (decodedContextMap[instrAndContext] != it.second) {
+        decodedContextMap[instrAndContext] = {-2, {}};
+      }
+      
+      // for (auto &it2 : it.second) {
+      //   decodedContextMap[instrAndContext].insert(it2);
+      // }
+    }
+  }
+
+  // // FIXME: this won't work because the context map is different
+  // for (auto &it : other.pointsToMap) {
+  //   if (pointsToMap.find(it.first) == pointsToMap.end()) {
+  //     pointsToMap[it.first] = it.second;
+  //   } else {
+  //     pointsToMap[it.first].merge(it.second);
+  //   }
+  // }
+}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.h
new file mode 100644
index 00000000..02600831
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/PointsToModule.h
@@ -0,0 +1,89 @@
+#include <cstdint>
+#include <unordered_set>
+#include <vector>
+
+#include "ProfilingModules/parallel_hashmap/phmap.h"
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "slamp_timestamp.h"
+
+#include "LocalWriteModule.h"
+#include "HTContainer.h"
+#include "ContextManager.h"
+
+enum class PointsToModAction : uint32_t {
+  INIT = 0,
+  // LOAD,
+  // STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_ENTRY,
+  LOOP_EXIT,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  POINTS_TO_INST,
+  POINTS_TO_ARG,
+  FINISHED
+};
+
+class PointsToModule : public LocalWriteModule {
+  private:
+    uint64_t slamp_iteration = 0;
+    uint64_t slamp_invocation = 0;
+    slamp::MemoryMap<MASK2_PT> *smmap = nullptr;
+    uint32_t target_loop_id = 0;
+
+    bool in_loop = false;
+
+    enum SpecPrivContextType {
+      TopContext = 0,
+      FunctionContext,
+      LoopContext,
+    };
+    using ContextHash = uint64_t;
+    using SpecPrivContextManager = NewContextManager<SpecPrivContextType, uint32_t, ContextHash>;
+    using ContextId = ContextId<SpecPrivContextType, uint32_t>;
+    std::unordered_set<ContextHash> targetLoopContexts;
+    SpecPrivContextManager contextManager;
+
+    using SlampAllocationUnit = TS;
+    // std::unordered_map<uint64_t, std::unordered_set<SlampAllocationUnit>> pointsToMap;
+    // HTMap_Set<uint64_t, SlampAllocationUnit, std::hash<uint64_t>, std::equal_to<>, 32> pointsToMap;
+    // phmap::flat_hash_map<uint64_t, phmap::flat_hash_set<SlampAllocationUnit>> pointsToMap;
+    HTMap_IsConstant<uint64_t> pointsToMap;
+
+    using InstrAndContext = std::pair<uint32_t, std::vector<ContextId>>;
+    std::map<InstrAndContext, InstrAndContext> decodedContextMap;
+    // std::map<InstrAndContext, std::set<InstrAndContext>> decodedContextMap;
+
+  public:
+  PointsToModule(uint32_t mask, uint32_t pattern)
+      : LocalWriteModule(mask, pattern) {
+    smmap = new slamp::MemoryMap<MASK2_PT>(mask, pattern, TIMESTAMP_SIZE_IN_BYTES);
+  }
+
+  ~PointsToModule() override { 
+    delete smmap; 
+  }
+
+  void init(uint32_t loop_id, uint32_t pid);
+  void fini(const char *filename);
+
+  void allocate(void *addr, uint32_t instr, uint64_t size);
+  void free(void *addr);
+  void loop_invoc();
+  void loop_iter();
+
+  void func_entry(uint32_t fcnId);
+  void func_exit(uint32_t fcnId);
+  void loop_entry(uint32_t loopId);
+  void loop_exit(uint32_t loopId);
+
+  void points_to_inst(uint32_t instId, void *ptr);
+
+  void points_to_arg(uint32_t fcnId, uint32_t argId, void *ptr);
+  void merge(PointsToModule &other);
+  void decode_all();
+};
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/context.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/context.h
new file mode 100644
index 00000000..ef67f377
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/context.h
@@ -0,0 +1,233 @@
+/* The context management
+ * ======================
+ * The definition of a context is very specific to the client. For SpecPriv,
+ * the dynamic context is defined as the function and loop stack.
+ *
+ * For loop-aware memory dependnece profiling, the context is the loop and the
+ * invocation and iteration count.
+ *
+ * The context information usually needs to be stored in the shadow memory.
+ * 
+ * The context management is responsible for keeping track the current context
+ * and creating a fixed length representation of any context.
+ *
+ */
+#pragma once
+
+#include <cassert>
+#include <iostream>
+#include <stack>
+#include <unordered_map>
+#include <utility>
+#include <map>
+#include <vector>
+
+namespace SLAMPLib {
+
+using ContextHash = size_t;
+
+/// The context is stack of the ContextId
+template <typename ContextId> struct Context {
+  ContextId id;
+  Context *parent;
+
+  Context(ContextId id, Context *parent) : id(std::move(id)), parent(parent) {}
+
+  /// Add a new context to the stack
+  Context *chain(ContextId id) { return new Context(id, this); }
+
+  static Context* getTopContext() {
+    return new Context(ContextId::getTopContextId(), nullptr);
+  }
+
+  ContextHash hash() {
+    ContextHash h = id.hash();
+    if (parent)
+      h ^= parent->hash();
+    return h;
+  }
+
+  /// Remove the top context from the stack
+  Context *pop() {
+    auto parent = this->parent;
+    // FIXME: is this ok to use?
+    delete this;
+    return parent;
+  }
+  using FlattenContext = std::vector<ContextId>;
+  using ContextIdType = ContextId;
+
+  /// make the context into a vector of only the context id
+  FlattenContext flatten() {
+    std::vector<ContextId> result;
+    Context *cur = this;
+    while (cur) {
+      result.push_back(cur->id);
+      cur = cur->parent;
+    }
+    return result;
+  };
+
+  /// print context
+  void print(std::ostream &os) {
+    os << "Context:\n";
+    Context *cur = this;
+    while (cur) {
+      cur->id.print(os);
+      cur = cur->parent;
+    }
+  }
+};
+
+/// Note that we do no need to keep track of
+/// all the objects that are alive
+template <class Context>
+struct ContextManager {
+  Context *activeContext;
+  bool contextChanged = true;
+
+  ContextManager() {
+    activeContext = Context::getTopContext();
+  }
+
+  std::unordered_map <ContextHash, typename Context::FlattenContext> contextMap;
+
+  ContextHash activeId() {
+    if (activeContext)
+      return activeContext->hash();
+    else
+      return 0;
+  }
+
+  void updateContext(typename Context::ContextIdType contextId) {
+    assert(activeContext && "active context is null");
+    /// maybe this is not a great idea, expose the semantics of the context to the manager
+    activeContext = activeContext->chain(contextId);
+    contextChanged = true;
+    // addContext(activeContext->hash(), *activeContext);
+  }
+
+  void popContext(typename Context::ContextIdType contextId) {
+    assert(activeContext && "active context is null");
+    contextChanged = true;
+
+    if (activeContext->id == contextId) {
+      activeContext = activeContext->pop();
+    } else {
+      // The context is not matching, could be due to the longjmp/setjmp etc or
+      // exception handling in C++
+      std::cerr << "Context mismatch! Current context: ";
+      auto tmp = activeContext;
+      while (tmp->parent) {
+        std::cerr << "(" << tmp->id.type << "," << tmp->id.metaId << ")->";
+        tmp = tmp->parent;
+      }
+      std::cerr << "(" << tmp->id.type << "," << tmp->id.metaId << ")->";
+      std::cerr << "Exiting context: (" << contextId.type << ","
+                << contextId.metaId << ")" << std::endl;
+
+      // Let's try to find the correct context
+      bool foundInStack = false;
+      while (activeContext->parent) {
+        activeContext = activeContext->pop();
+        if (activeContext->id == contextId) {
+          foundInStack = true;
+          break;
+        }
+      }
+
+      assert(foundInStack && "Could not find the exiting context in the stack");
+    }
+  }
+
+  void addContext(ContextHash hash, Context &context) {
+
+    // if exist one but not the same, then we have a problem
+    if (contextMap.count(hash) && contextMap[hash] != context.flatten()) {
+      // FIXME: need to turn this back on
+      // assert(false && "Context hash collision");
+    }
+
+    // insert the context
+    contextMap[hash] = context.flatten();
+  }
+};
+
+namespace SpecPrivLib {
+enum SpecPrivContextType {
+  TopContext = 0,
+  FunctionContext,
+  LoopContext,
+};
+
+
+struct ContextId {
+  SpecPrivContextType type;
+  uint32_t metaId;
+  ContextId(SpecPrivContextType type, uint32_t id) : type(type), metaId(id) {}
+  ContextId(std::pair<SpecPrivContextType, int32_t> p)
+      : type(p.first), metaId(p.second) {}
+  static ContextId getTopContextId() { return {TopContext, 0}; }
+  // id left shift 2 bits and or with type
+  ContextHash hash() {
+    return (static_cast<ContextHash>(metaId) << 2) | static_cast<ContextHash>(type);
+  }
+
+  bool operator==(const ContextId &other) const {
+    return type == other.type && metaId == other.metaId;
+  }
+
+  bool operator<(const ContextId &other) const {
+    return type < other.type || (type == other.type && metaId < other.metaId);
+  }
+
+  void print(std::ostream &os) {
+    os << "ContextId: " << type << " " << metaId << "\n";
+  }
+};
+using SpecPrivContext = Context<ContextId>;
+
+struct SpecPrivContextManager : public ContextManager<SpecPrivContext> {
+
+  std::map<std::vector<ContextId>, ContextHash> contextIdHashMap;
+  size_t contextIdHashCounter = 1;
+  
+  ContextHash cachedContextHash;
+
+  ContextHash encodeContext(SpecPrivContext context) {
+    std::vector<ContextId> flattenContext = context.flatten();
+    if (contextIdHashMap.count(flattenContext)) {
+      return contextIdHashMap[flattenContext];
+    } else {
+      contextIdHashMap[flattenContext] = contextIdHashCounter;
+      contextMap[contextIdHashCounter] = flattenContext;
+
+      return contextIdHashCounter++;
+    }
+  }
+
+  ContextHash encodeActiveContext() {
+    // std::cerr << "encodeActiveContext: ";
+    // activeContext->print(std::cerr);
+    if (!contextChanged) {
+      return cachedContextHash;
+    } else {
+      cachedContextHash = encodeContext(*activeContext);
+      contextChanged = false;
+      return cachedContextHash;
+    }
+  }
+
+  std::vector<ContextId> decodeContext(ContextHash hash) {
+    if (contextMap.count(hash)) {
+      return contextMap[hash];
+    } else {
+      assert(false && "Could not find the context");
+      return {};
+    }
+  }
+
+};
+}; // namespace SpecPrivLib
+
+} // namespace SLAMPLib
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/btree.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/btree.h
new file mode 100644
index 00000000..8aee516a
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/btree.h
@@ -0,0 +1,4087 @@
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#ifndef PHMAP_BTREE_BTREE_CONTAINER_H_
+#define PHMAP_BTREE_BTREE_CONTAINER_H_
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+
+    #pragma warning(disable : 4127) // conditional expression is constant
+    #pragma warning(disable : 4324) // structure was padded due to alignment specifier
+    #pragma warning(disable : 4355) // 'this': used in base member initializer list
+    #pragma warning(disable : 4365) // conversion from 'int' to 'const unsigned __int64', signed/unsigned mismatch
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4623) // default constructor was implicitly defined as deleted
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) //  selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+    #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order in braced initializer list
+    #pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+    #pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
+#endif
+
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <new>
+
+#include "phmap_fwd_decl.h"
+#include "phmap_base.h"
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    #include <string_view>
+#endif
+
+// MSVC constructibility traits do not detect destructor properties and so our
+// implementations should not use them as a source-of-truth.
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+    #define PHMAP_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
+#endif
+
+namespace phmap {
+
+    // Defined and documented later on in this file.
+    template <typename T>
+    struct is_trivially_destructible;
+
+    // Defined and documented later on in this file.
+    template <typename T>
+    struct is_trivially_move_assignable;
+
+    namespace type_traits_internal {
+
+        // Silence MSVC warnings about the destructor being defined as deleted.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+    #pragma warning(push)
+    #pragma warning(disable : 4624)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+        template <class T>
+        union SingleMemberUnion {
+            T t;
+        };
+
+        // Restore the state of the destructor warning that was silenced above.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+    #pragma warning(pop)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+        template <class T>
+        struct IsTriviallyMoveConstructibleObject
+            : std::integral_constant<
+            bool, std::is_move_constructible<
+                      type_traits_internal::SingleMemberUnion<T>>::value &&
+            phmap::is_trivially_destructible<T>::value> {};
+
+        template <class T>
+        struct IsTriviallyCopyConstructibleObject
+            : std::integral_constant<
+            bool, std::is_copy_constructible<
+                      type_traits_internal::SingleMemberUnion<T>>::value &&
+            phmap::is_trivially_destructible<T>::value> {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference : std::false_type {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference<T&>
+            : phmap::is_trivially_move_assignable<T>::type {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference<T&&>
+            : phmap::is_trivially_move_assignable<T>::type {};
+
+    }  // namespace type_traits_internal
+
+
+    template <typename... Ts>
+    using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+
+    template <typename T>
+    struct is_function
+        : std::integral_constant<
+        bool, !(std::is_reference<T>::value ||
+                std::is_const<typename std::add_const<T>::type>::value)> {};
+
+
+    namespace type_traits_internal {
+
+        template <typename T>
+        class is_trivially_copyable_impl {
+            using ExtentsRemoved = typename std::remove_all_extents<T>::type;
+            static constexpr bool kIsCopyOrMoveConstructible =
+                std::is_copy_constructible<ExtentsRemoved>::value ||
+                std::is_move_constructible<ExtentsRemoved>::value;
+            static constexpr bool kIsCopyOrMoveAssignable =
+                phmap::is_copy_assignable<ExtentsRemoved>::value ||
+                phmap::is_move_assignable<ExtentsRemoved>::value;
+
+        public:
+            static constexpr bool kValue =
+                (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
+                (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
+                (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
+                is_trivially_destructible<ExtentsRemoved>::value &&
+                // We need to check for this explicitly because otherwise we'll say
+                // references are trivial copyable when compiled by MSVC.
+                !std::is_reference<ExtentsRemoved>::value;
+        };
+
+        template <typename T>
+        struct is_trivially_copyable
+            : std::integral_constant<
+            bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue> {};
+    }  // namespace type_traits_internal
+
+    namespace swap_internal {
+
+        // Necessary for the traits.
+        using std::swap;
+
+        // This declaration prevents global `swap` and `phmap::swap` overloads from being
+        // considered unless ADL picks them up.
+        void swap();
+
+        template <class T>
+        using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+        // NOTE: This dance with the default template parameter is for MSVC.
+        template <class T,
+                  class IsNoexcept = std::integral_constant<
+                      bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
+            using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
+
+        template <class T>
+        struct IsSwappable
+            : phmap::type_traits_internal::is_detected<IsSwappableImpl, T> {};
+
+        template <class T>
+        struct IsNothrowSwappable
+            : phmap::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
+
+        template <class T, phmap::enable_if_t<IsSwappable<T>::value, int> = 0>
+        void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
+            swap(lhs, rhs);
+        }
+
+       using StdSwapIsUnconstrained = IsSwappable<void()>;
+
+    }  // namespace swap_internal
+
+    namespace type_traits_internal {
+
+        // Make the swap-related traits/function accessible from this namespace.
+        using swap_internal::IsNothrowSwappable;
+        using swap_internal::IsSwappable;
+        using swap_internal::Swap;
+        using swap_internal::StdSwapIsUnconstrained;
+
+    }  // namespace type_traits_internal
+
+    namespace compare_internal {
+
+        using value_type = int8_t;
+
+        template <typename T>
+        struct Fail {
+            static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
+        };
+
+        template <typename NullPtrT = std::nullptr_t>
+        struct OnlyLiteralZero {
+            constexpr OnlyLiteralZero(NullPtrT) noexcept {}  // NOLINT
+
+            template <
+                typename T,
+                typename = typename std::enable_if<
+                    std::is_same<T, std::nullptr_t>::value ||
+                    (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
+                typename = typename Fail<T>::type>
+                OnlyLiteralZero(T);  // NOLINT
+        };
+
+        enum class eq : value_type {
+            equal = 0,
+                equivalent = equal,
+                nonequal = 1,
+                nonequivalent = nonequal,
+                };
+
+        enum class ord : value_type { less = -1, greater = 1 };
+
+        enum class ncmp : value_type { unordered = -127 };
+
+#if defined(__cpp_inline_variables) && !defined(_MSC_VER)
+
+#define PHMAP_COMPARE_INLINE_BASECLASS_DECL(name)
+
+#define PHMAP_COMPARE_INLINE_SUBCLASS_DECL(type, name)  \
+        static const type name;
+
+#define PHMAP_COMPARE_INLINE_INIT(type, name, init) \
+        inline constexpr type type::name(init)
+
+#else  // __cpp_inline_variables
+
+#define PHMAP_COMPARE_INLINE_BASECLASS_DECL(name)   \
+        static const T name;
+
+#define PHMAP_COMPARE_INLINE_SUBCLASS_DECL(type, name)
+
+#define PHMAP_COMPARE_INLINE_INIT(type, name, init)             \
+        template <typename T>                                   \
+        const T compare_internal::type##_base<T>::name(init)
+
+#endif  // __cpp_inline_variables
+
+        // These template base classes allow for defining the values of the constants
+        // in the header file (for performance) without using inline variables (which
+        // aren't available in C++11).
+        template <typename T>
+        struct weak_equality_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequivalent)
+        };
+
+        template <typename T>
+        struct strong_equality_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequivalent)
+        };
+
+        template <typename T>
+        struct partial_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(unordered)
+        };
+
+        template <typename T>
+        struct weak_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+        };
+
+        template <typename T>
+        struct strong_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+        };
+
+    }  // namespace compare_internal
+
+    class weak_equality
+        : public compare_internal::weak_equality_base<weak_equality> {
+        explicit constexpr weak_equality(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::weak_equality_base<weak_equality>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent)
+
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         weak_equality v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         weak_equality v) noexcept {
+            return 0 != v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    PHMAP_COMPARE_INLINE_INIT(weak_equality, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
+                              compare_internal::eq::nonequivalent);
+
+    class strong_equality
+        : public compare_internal::strong_equality_base<strong_equality> {
+        explicit constexpr strong_equality(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::strong_equality_base<strong_equality>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent)
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         strong_equality v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         strong_equality v) noexcept {
+            return 0 != v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, nonequal,
+                              compare_internal::eq::nonequal);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
+                              compare_internal::eq::nonequivalent);
+
+    class partial_ordering
+        : public compare_internal::partial_ordering_base<partial_ordering> {
+        explicit constexpr partial_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr partial_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::partial_ordering_base<partial_ordering>;
+
+        constexpr bool is_ordered() const noexcept {
+            return value_ !=
+                compare_internal::value_type(compare_internal::ncmp::unordered);
+        }
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered)
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return !v.is_ordered() || v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return !v.is_ordered() || 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        partial_ordering v) noexcept {
+            return v.is_ordered() && 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        partial_ordering v) noexcept {
+            return v.is_ordered() && 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, greater,
+                              compare_internal::ord::greater);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, unordered,
+                              compare_internal::ncmp::unordered);
+
+    class weak_ordering
+        : public compare_internal::weak_ordering_base<weak_ordering> {
+        explicit constexpr weak_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr weak_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::weak_ordering_base<weak_ordering>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater)
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        constexpr operator partial_ordering() const noexcept {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent
+                : (value_ < 0 ? partial_ordering::less
+                   : partial_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        weak_ordering v) noexcept {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        weak_ordering v) noexcept {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, greater,
+                              compare_internal::ord::greater);
+
+    class strong_ordering
+        : public compare_internal::strong_ordering_base<strong_ordering> {
+        explicit constexpr strong_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr strong_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::strong_ordering_base<strong_ordering>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater)
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        constexpr operator strong_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? strong_equality::equal : strong_equality::nonequal;
+        }
+        constexpr operator partial_ordering() const noexcept {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent
+                : (value_ < 0 ? partial_ordering::less
+                   : partial_ordering::greater);
+        }
+        constexpr operator weak_ordering() const noexcept {  // NOLINT
+            return value_ == 0
+                ? weak_ordering::equivalent
+                : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        strong_ordering v) noexcept {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        strong_ordering v) noexcept {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, greater,
+                              compare_internal::ord::greater);
+
+#undef PHMAP_COMPARE_INLINE_BASECLASS_DECL
+#undef PHMAP_COMPARE_INLINE_SUBCLASS_DECL
+#undef PHMAP_COMPARE_INLINE_INIT
+
+    namespace compare_internal {
+        // We also provide these comparator adapter functions for internal phmap use.
+
+        // Helper functions to do a boolean comparison of two keys given a boolean
+        // or three-way comparator.
+        // SFINAE prevents implicit conversions to bool (such as from int).
+        template <typename BoolType,
+                  phmap::enable_if_t<std::is_same<bool, BoolType>::value, int> = 0>
+        constexpr bool compare_result_as_less_than(const BoolType r) { return r; }
+        constexpr bool compare_result_as_less_than(const phmap::weak_ordering r) {
+            return r < 0;
+        }
+
+        template <typename Compare, typename K, typename LK>
+        constexpr bool do_less_than_comparison(const Compare &compare, const K &x,
+                                               const LK &y) {
+            return compare_result_as_less_than(compare(x, y));
+        }
+
+        // Helper functions to do a three-way comparison of two keys given a boolean or
+        // three-way comparator.
+        // SFINAE prevents implicit conversions to int (such as from bool).
+        template <typename Int,
+                  phmap::enable_if_t<std::is_same<int, Int>::value, int> = 0>
+        constexpr phmap::weak_ordering compare_result_as_ordering(const Int c) {
+            return c < 0 ? phmap::weak_ordering::less
+                       : c == 0 ? phmap::weak_ordering::equivalent
+                       : phmap::weak_ordering::greater;
+        }
+        constexpr phmap::weak_ordering compare_result_as_ordering(
+            const phmap::weak_ordering c) {
+            return c;
+        }
+
+        template <
+            typename Compare, typename K, typename LK,
+            phmap::enable_if_t<!std::is_same<bool, phmap::invoke_result_t<
+                                                       Compare, const K &, const LK &>>::value,
+                               int> = 0>
+            constexpr phmap::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                                   const K &x, const LK &y) {
+            return compare_result_as_ordering(compare(x, y));
+        }
+        template <
+            typename Compare, typename K, typename LK,
+            phmap::enable_if_t<std::is_same<bool, phmap::invoke_result_t<Compare,
+            const K &, const LK &>>::value,
+                               int> = 0>
+            constexpr phmap::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                                   const K &x, const LK &y) {
+            return compare(x, y) ? phmap::weak_ordering::less
+                : compare(y, x) ? phmap::weak_ordering::greater
+                : phmap::weak_ordering::equivalent;
+        }
+
+    }  // namespace compare_internal
+}
+
+
+namespace phmap {
+
+namespace priv {
+
+    // A helper class that indicates if the Compare parameter is a key-compare-to
+    // comparator.
+    template <typename Compare, typename T>
+    using btree_is_key_compare_to =
+        std::is_convertible<phmap::invoke_result_t<Compare, const T &, const T &>,
+                            phmap::weak_ordering>;
+
+    struct StringBtreeDefaultLess {
+        using is_transparent = void;
+
+        StringBtreeDefaultLess() = default;
+
+        // Compatibility constructor.
+        StringBtreeDefaultLess(std::less<std::string>) {}       // NOLINT
+#if PHMAP_HAVE_STD_STRING_VIEW
+        StringBtreeDefaultLess(std::less<std::string_view>) {}  // NOLINT
+        StringBtreeDefaultLess(phmap::Less<std::string_view>) {}  // NOLINT
+
+        phmap::weak_ordering operator()(std::string_view lhs,
+                                        std::string_view rhs) const {
+            return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+        }
+#else
+        phmap::weak_ordering operator()(std::string lhs,
+                                        std::string rhs) const {
+            return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+        }
+#endif
+    };
+
+    struct StringBtreeDefaultGreater {
+        using is_transparent = void;
+
+        StringBtreeDefaultGreater() = default;
+
+        StringBtreeDefaultGreater(std::greater<std::string>) {}       // NOLINT
+#if PHMAP_HAVE_STD_STRING_VIEW
+        StringBtreeDefaultGreater(std::greater<std::string_view>) {}  // NOLINT
+
+        phmap::weak_ordering operator()(std::string_view lhs,
+                                        std::string_view rhs) const {
+            return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+        }
+#else
+        phmap::weak_ordering operator()(std::string lhs,
+                                        std::string rhs) const {
+            return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+        }
+#endif
+    };
+
+    // A helper class to convert a boolean comparison into a three-way "compare-to"
+    // comparison that returns a negative value to indicate less-than, zero to
+    // indicate equality and a positive value to indicate greater-than. This helper
+    // class is specialized for less<std::string>, greater<std::string>,
+    // less<std::string_view>, and greater<std::string_view>.
+    //
+    // key_compare_to_adapter is provided so that btree users
+    // automatically get the more efficient compare-to code when using common
+    // google string types with common comparison functors.
+    // These string-like specializations also turn on heterogeneous lookup by
+    // default.
+    template <typename Compare>
+    struct key_compare_to_adapter {
+        using type = Compare;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::less<std::string>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<phmap::Less<std::string>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::greater<std::string>> {
+        using type = StringBtreeDefaultGreater;
+    };
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    template <>
+    struct key_compare_to_adapter<std::less<std::string_view>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<phmap::Less<std::string_view>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::greater<std::string_view>> {
+        using type = StringBtreeDefaultGreater;
+    };
+#endif
+
+    template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+              bool Multi, typename SlotPolicy>
+    struct common_params {
+        // If Compare is a common comparator for a std::string-like type, then we adapt it
+        // to use heterogeneous lookup and to be a key-compare-to comparator.
+        using key_compare = typename key_compare_to_adapter<Compare>::type;
+        // A type which indicates if we have a key-compare-to functor or a plain old
+        // key-compare functor.
+        using is_key_compare_to = btree_is_key_compare_to<key_compare, Key>;
+
+        using allocator_type = Alloc;
+        using key_type = Key;
+        using size_type = std::size_t ;
+        using difference_type = ptrdiff_t;
+
+        // True if this is a multiset or multimap.
+        using is_multi_container = std::integral_constant<bool, Multi>;
+
+        using slot_policy = SlotPolicy;
+        using slot_type = typename slot_policy::slot_type;
+        using value_type = typename slot_policy::value_type;
+        using init_type = typename slot_policy::mutable_value_type;
+        using pointer = value_type *;
+        using const_pointer = const value_type *;
+        using reference = value_type &;
+        using const_reference = const value_type &;
+
+        enum {
+            kTargetNodeSize = TargetNodeSize,
+
+            // Upper bound for the available space for values. This is largest for leaf
+            // nodes, which have overhead of at least a pointer + 4 bytes (for storing
+            // 3 field_types and an enum).
+            kNodeSlotSpace =
+                TargetNodeSize - /*minimum overhead=*/(sizeof(void *) + 4),
+        };
+
+        // This is an integral type large enough to hold as many
+        // ValueSize-values as will fit a node of TargetNodeSize bytes.
+        using node_count_type =
+            phmap::conditional_t<(kNodeSlotSpace / sizeof(slot_type) >
+                                   (std::numeric_limits<uint8_t>::max)()),
+            uint16_t, uint8_t>;  // NOLINT
+
+        // The following methods are necessary for passing this struct as PolicyTraits
+        // for node_handle and/or are used within btree.
+        static value_type &element(slot_type *slot) {
+            return slot_policy::element(slot);
+        }
+        static const value_type &element(const slot_type *slot) {
+            return slot_policy::element(slot);
+        }
+        template <class... Args>
+        static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
+            slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+        }
+        static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+            slot_policy::construct(alloc, slot, other);
+        }
+        static void destroy(Alloc *alloc, slot_type *slot) {
+            slot_policy::destroy(alloc, slot);
+        }
+        static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
+            construct(alloc, new_slot, old_slot);
+            destroy(alloc, old_slot);
+        }
+        static void swap(Alloc *alloc, slot_type *a, slot_type *b) {
+            slot_policy::swap(alloc, a, b);
+        }
+        static void move(Alloc *alloc, slot_type *src, slot_type *dest) {
+            slot_policy::move(alloc, src, dest);
+        }
+        static void move(Alloc *alloc, slot_type *first, slot_type *last,
+                         slot_type *result) {
+            slot_policy::move(alloc, first, last, result);
+        }
+    };
+
+    // A parameters structure for holding the type parameters for a btree_map.
+    // Compare and Alloc should be nothrow copy-constructible.
+    template <typename Key, typename Data, typename Compare, typename Alloc,
+              int TargetNodeSize, bool Multi>
+    struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
+                                      phmap::priv::map_slot_policy<Key, Data>> {
+        using super_type = typename map_params::common_params;
+        using mapped_type = Data;
+        // This type allows us to move keys when it is safe to do so. It is safe
+        // for maps in which value_type and mutable_value_type are layout compatible.
+        using slot_policy = typename super_type::slot_policy;
+        using slot_type = typename super_type::slot_type;
+        using value_type = typename super_type::value_type;
+        using init_type = typename super_type::init_type;
+
+        using key_compare = typename super_type::key_compare;
+        // Inherit from key_compare for empty base class optimization.
+        struct value_compare : private key_compare {
+            value_compare() = default;
+            explicit value_compare(const key_compare &cmp) : key_compare(cmp) {}
+
+            template <typename T, typename U>
+            auto operator()(const T &left, const U &right) const
+                -> decltype(std::declval<key_compare>()(left.first, right.first)) {
+                return key_compare::operator()(left.first, right.first);
+            }
+        };
+        using is_map_container = std::true_type;
+
+        static const Key &key(const value_type &x) { return x.first; }
+        static const Key &key(const init_type &x) { return x.first; }
+        static const Key &key(const slot_type *x) { return slot_policy::key(x); }
+        static mapped_type &value(value_type *value) { return value->second; }
+    };
+
+    // This type implements the necessary functions from the
+    // btree::priv::slot_type interface.
+    template <typename Key>
+    struct set_slot_policy {
+        using slot_type = Key;
+        using value_type = Key;
+        using mutable_value_type = Key;
+
+        static value_type &element(slot_type *slot) { return *slot; }
+        static const value_type &element(const slot_type *slot) { return *slot; }
+
+        template <typename Alloc, class... Args>
+        static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
+            phmap::allocator_traits<Alloc>::construct(*alloc, slot,
+                                                       std::forward<Args>(args)...);
+        }
+
+        template <typename Alloc>
+        static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+            phmap::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
+        }
+
+        template <typename Alloc>
+        static void destroy(Alloc *alloc, slot_type *slot) {
+            phmap::allocator_traits<Alloc>::destroy(*alloc, slot);
+        }
+
+        template <typename Alloc>
+        static void swap(Alloc * /*alloc*/, slot_type *a, slot_type *b) {
+            using std::swap;
+            swap(*a, *b);
+        }
+
+        template <typename Alloc>
+        static void move(Alloc * /*alloc*/, slot_type *src, slot_type *dest) {
+            *dest = std::move(*src);
+        }
+
+        template <typename Alloc>
+        static void move(Alloc *alloc, slot_type *first, slot_type *last,
+                         slot_type *result) {
+            for (slot_type *src = first, *dest = result; src != last; ++src, ++dest)
+                move(alloc, src, dest);
+        }
+    };
+
+    // A parameters structure for holding the type parameters for a btree_set.
+    // Compare and Alloc should be nothrow copy-constructible.
+    template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+              bool Multi>
+    struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
+                                      set_slot_policy<Key>> {
+        using value_type = Key;
+        using slot_type = typename set_params::common_params::slot_type;
+        using value_compare = typename set_params::common_params::key_compare;
+        using is_map_container = std::false_type;
+
+        static const Key &key(const value_type &x) { return x; }
+        static const Key &key(const slot_type *x) { return *x; }
+    };
+
+    // An adapter class that converts a lower-bound compare into an upper-bound
+    // compare. Note: there is no need to make a version of this adapter specialized
+    // for key-compare-to functors because the upper-bound (the first value greater
+    // than the input) is never an exact match.
+    template <typename Compare>
+    struct upper_bound_adapter {
+        explicit upper_bound_adapter(const Compare &c) : comp(c) {}
+        template <typename K, typename LK>
+        bool operator()(const K &a, const LK &b) const {
+            // Returns true when a is not greater than b.
+            return !phmap::compare_internal::compare_result_as_less_than(comp(b, a));
+        }
+
+    private:
+        Compare comp;
+    };
+
+    enum class MatchKind : uint8_t { kEq, kNe };
+
+    template <typename V, bool IsCompareTo>
+    struct SearchResult {
+        V value;
+        MatchKind match;
+
+        static constexpr bool HasMatch() { return true; }
+        bool IsEq() const { return match == MatchKind::kEq; }
+    };
+
+    // When we don't use CompareTo, `match` is not present.
+    // This ensures that callers can't use it accidentally when it provides no
+    // useful information.
+    template <typename V>
+    struct SearchResult<V, false> {
+        V value;
+
+        static constexpr bool HasMatch() { return false; }
+        static constexpr bool IsEq() { return false; }
+    };
+
+    // A node in the btree holding. The same node type is used for both internal
+    // and leaf nodes in the btree, though the nodes are allocated in such a way
+    // that the children array is only valid in internal nodes.
+    template <typename Params>
+    class btree_node {
+        using is_key_compare_to = typename Params::is_key_compare_to;
+        using is_multi_container = typename Params::is_multi_container;
+        using field_type = typename Params::node_count_type;
+        using allocator_type = typename Params::allocator_type;
+        using slot_type = typename Params::slot_type;
+
+    public:
+        using params_type = Params;
+        using key_type = typename Params::key_type;
+        using value_type = typename Params::value_type;
+        using pointer = typename Params::pointer;
+        using const_pointer = typename Params::const_pointer;
+        using reference = typename Params::reference;
+        using const_reference = typename Params::const_reference;
+        using key_compare = typename Params::key_compare;
+        using size_type = typename Params::size_type;
+        using difference_type = typename Params::difference_type;
+
+        // Btree decides whether to use linear node search as follows:
+        //   - If the key is arithmetic and the comparator is std::less or
+        //     std::greater, choose linear.
+        //   - Otherwise, choose binary.
+        // TODO(ezb): Might make sense to add condition(s) based on node-size.
+        using use_linear_search = std::integral_constant<
+            bool,
+            std::is_arithmetic<key_type>::value &&
+            (std::is_same<phmap::Less<key_type>, key_compare>::value ||
+             std::is_same<std::less<key_type>, key_compare>::value ||
+             std::is_same<std::greater<key_type>, key_compare>::value)>;
+
+
+        ~btree_node() = default;
+        btree_node(btree_node const &) = delete;
+        btree_node &operator=(btree_node const &) = delete;
+
+        // Public for EmptyNodeType.
+        constexpr static size_type Alignment() {
+            static_assert(LeafLayout(1).Alignment() == InternalLayout().Alignment(),
+                          "Alignment of all nodes must be equal.");
+            return (size_type)InternalLayout().Alignment();
+        }
+
+    protected:
+        btree_node() = default;
+
+    private:
+        using layout_type = phmap::priv::Layout<btree_node *, field_type,
+                                                               slot_type, btree_node *>;
+        constexpr static size_type SizeWithNValues(size_type n) {
+            return (size_type)layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ (size_t)n,
+                               /*children*/ 0)
+                .AllocSize();
+        }
+        // A lower bound for the overhead of fields other than values in a leaf node.
+        constexpr static size_type MinimumOverhead() {
+            return (size_type)(SizeWithNValues(1) - sizeof(value_type));
+        }
+
+        // Compute how many values we can fit onto a leaf node taking into account
+        // padding.
+        constexpr static size_type NodeTargetValues(const int begin, const int end) {
+            return begin == end ? begin
+                : SizeWithNValues((begin + end) / 2 + 1) >
+                params_type::kTargetNodeSize
+                ? NodeTargetValues(begin, (begin + end) / 2)
+                : NodeTargetValues((begin + end) / 2 + 1, end);
+        }
+
+        enum {
+            kTargetNodeSize = params_type::kTargetNodeSize,
+            kNodeTargetValues = NodeTargetValues(0, params_type::kTargetNodeSize),
+
+            // We need a minimum of 3 values per internal node in order to perform
+            // splitting (1 value for the two nodes involved in the split and 1 value
+            // propagated to the parent as the delimiter for the split).
+            kNodeValues = kNodeTargetValues >= 3 ? kNodeTargetValues : 3,
+
+            // The node is internal (i.e. is not a leaf node) if and only if `max_count`
+            // has this value.
+            kInternalNodeMaxCount = 0,
+        };
+
+        // Leaves can have less than kNodeValues values.
+        constexpr static layout_type LeafLayout(const int max_values = kNodeValues) {
+            return layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ (size_t)max_values,
+                               /*children*/ 0);
+        }
+        constexpr static layout_type InternalLayout() {
+            return layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ kNodeValues,
+                               /*children*/ kNodeValues + 1);
+        }
+        constexpr static size_type LeafSize(const int max_values = kNodeValues) {
+            return (size_type)LeafLayout(max_values).AllocSize();
+        }
+        constexpr static size_type InternalSize() {
+            return (size_type)InternalLayout().AllocSize();
+        }
+
+        // N is the index of the type in the Layout definition.
+        // ElementType<N> is the Nth type in the Layout definition.
+        template <size_type N>
+        inline typename layout_type::template ElementType<N> *GetField() {
+            // We assert that we don't read from values that aren't there.
+            assert(N < 3 || !leaf());
+            return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
+        }
+
+        template <size_type N>
+        inline const typename layout_type::template ElementType<N> *GetField() const {
+            assert(N < 3 || !leaf());
+            return InternalLayout().template Pointer<N>(
+                reinterpret_cast<const char *>(this));
+        }
+
+        void set_parent(btree_node *p)     { *GetField<0>() = p; }
+        field_type &mutable_count()        { return GetField<1>()[2]; }
+        slot_type *slot(size_type i)       { return &GetField<2>()[i]; }
+        const slot_type *slot(size_type i) const { return &GetField<2>()[i]; }
+        void set_position(field_type v)    { GetField<1>()[0] = v; }
+        void set_start(field_type v)       { GetField<1>()[1] = v; }
+        void set_count(field_type v)       { GetField<1>()[2] = v; }
+        void set_max_count(field_type v)   { GetField<1>()[3] = v; }
+
+    public:
+        // Whether this is a leaf node or not. This value doesn't change after the
+        // node is created.
+        bool leaf() const { return GetField<1>()[3] != kInternalNodeMaxCount; }
+
+        // Getter for the position of this node in its parent.
+        field_type position() const { return GetField<1>()[0]; }
+
+        // Getter for the offset of the first value in the `values` array.
+        field_type start() const { return GetField<1>()[1]; }
+
+        // Getters for the number of values stored in this node.
+        field_type count() const { return GetField<1>()[2]; }
+        field_type max_count() const {
+            // Internal nodes have max_count==kInternalNodeMaxCount.
+            // Leaf nodes have max_count in [1, kNodeValues].
+            const field_type max_cnt = GetField<1>()[3];
+            return max_cnt == field_type{kInternalNodeMaxCount}
+            ? field_type{kNodeValues}
+            : max_cnt;
+        }
+
+        // Getter for the parent of this node.
+        btree_node *parent() const { return *GetField<0>(); }
+        // Getter for whether the node is the root of the tree. The parent of the
+        // root of the tree is the leftmost node in the tree which is guaranteed to
+        // be a leaf.
+        bool is_root() const { return parent()->leaf(); }
+        void make_root() {
+            assert(parent()->is_root());
+            set_parent(parent()->parent());
+        }
+
+        // Getters for the key/value at position i in the node.
+        const key_type &key(size_type i) const { return params_type::key(slot(i)); }
+        reference value(size_type i) { return params_type::element(slot(i)); }
+        const_reference value(size_type i) const { return params_type::element(slot(i)); }
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+        // Getters/setter for the child at position i in the node.
+        btree_node *child(size_type i) const { return GetField<3>()[i]; }
+        btree_node *&mutable_child(size_type i) { return GetField<3>()[i]; }
+        void clear_child(size_type i) {
+            phmap::priv::SanitizerPoisonObject(&mutable_child(i));
+        }
+        void set_child(size_type i, btree_node *c) {
+            phmap::priv::SanitizerUnpoisonObject(&mutable_child(i));
+            mutable_child(i) = c;
+            c->set_position((field_type)i);
+        }
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+        void init_child(int i, btree_node *c) {
+            set_child(i, c);
+            c->set_parent(this);
+        }
+
+        // Returns the position of the first value whose key is not less than k.
+        template <typename K>
+        SearchResult<int, is_key_compare_to::value> lower_bound(
+            const K &k, const key_compare &comp) const {
+            return use_linear_search::value ? linear_search(k, comp)
+                : binary_search(k, comp);
+        }
+        // Returns the position of the first value whose key is greater than k.
+        template <typename K>
+        int upper_bound(const K &k, const key_compare &comp) const {
+            auto upper_compare = upper_bound_adapter<key_compare>(comp);
+            return use_linear_search::value ? linear_search(k, upper_compare).value
+                : binary_search(k, upper_compare).value;
+        }
+
+        template <typename K, typename Compare>
+        SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+        linear_search(const K &k, const Compare &comp) const {
+            return linear_search_impl(k, 0, count(), comp,
+                                      btree_is_key_compare_to<Compare, key_type>());
+        }
+
+        template <typename K, typename Compare>
+        SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+        binary_search(const K &k, const Compare &comp) const {
+            return binary_search_impl(k, 0, count(), comp,
+                                      btree_is_key_compare_to<Compare, key_type>());
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // linear search performed using plain compare.
+        template <typename K, typename Compare>
+        SearchResult<int, false> linear_search_impl(
+            const K &k, int s, const int e, const Compare &comp,
+            std::false_type /* IsCompareTo */) const {
+            while (s < e) {
+                if (!comp(key(s), k)) {
+                    break;
+                }
+                ++s;
+            }
+            return {s};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // linear search performed using compare-to.
+        template <typename K, typename Compare>
+        SearchResult<int, true> linear_search_impl(
+            const K &k, int s, const int e, const Compare &comp,
+            std::true_type /* IsCompareTo */) const {
+            while (s < e) {
+                const phmap::weak_ordering c = comp(key(s), k);
+                if (c == 0) {
+                    return {s, MatchKind::kEq};
+                } else if (c > 0) {
+                    break;
+                }
+                ++s;
+            }
+            return {s, MatchKind::kNe};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // binary search performed using plain compare.
+        template <typename K, typename Compare>
+        SearchResult<int, false> binary_search_impl(
+            const K &k, int s, int e, const Compare &comp,
+            std::false_type /* IsCompareTo */) const {
+            while (s != e) {
+                const int mid = (s + e) >> 1;
+                if (comp(key(mid), k)) {
+                    s = mid + 1;
+                } else {
+                    e = mid;
+                }
+            }
+            return {s};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // binary search performed using compare-to.
+        template <typename K, typename CompareTo>
+        SearchResult<int, true> binary_search_impl(
+            const K &k, int s, int e, const CompareTo &comp,
+            std::true_type /* IsCompareTo */) const {
+            if (is_multi_container::value) {
+                MatchKind exact_match = MatchKind::kNe;
+                while (s != e) {
+                    const int mid = (s + e) >> 1;
+                    const phmap::weak_ordering c = comp(key(mid), k);
+                    if (c < 0) {
+                        s = mid + 1;
+                    } else {
+                        e = mid;
+                        if (c == 0) {
+                            // Need to return the first value whose key is not less than k,
+                            // which requires continuing the binary search if this is a
+                            // multi-container.
+                            exact_match = MatchKind::kEq;
+                        }
+                    }
+                }
+                return {s, exact_match};
+            } else {  // Not a multi-container.
+                while (s != e) {
+                    const int mid = (s + e) >> 1;
+                    const phmap::weak_ordering c = comp(key(mid), k);
+                    if (c < 0) {
+                        s = mid + 1;
+                    } else if (c > 0) {
+                        e = mid;
+                    } else {
+                        return {mid, MatchKind::kEq};
+                    }
+                }
+                return {s, MatchKind::kNe};
+            }
+        }
+
+        // Emplaces a value at position i, shifting all existing values and
+        // children at positions >= i to the right by 1.
+        template <typename... Args>
+        void emplace_value(size_type i, allocator_type *alloc, Args &&... args);
+
+        // Removes the value at position i, shifting all existing values and children
+        // at positions > i to the left by 1.
+        void remove_value(int i, allocator_type *alloc);
+
+        // Removes the values at positions [i, i + to_erase), shifting all values
+        // after that range to the left by to_erase. Does not change children at all.
+        void remove_values_ignore_children(int i, size_type to_erase,
+                                           allocator_type *alloc);
+
+        // Rebalances a node with its right sibling.
+        void rebalance_right_to_left(int to_move, btree_node *right,
+                                     allocator_type *alloc);
+        void rebalance_left_to_right(int to_move, btree_node *right,
+                                     allocator_type *alloc);
+
+        // Splits a node, moving a portion of the node's values to its right sibling.
+        void split(int insert_position, btree_node *dest, allocator_type *alloc);
+
+        // Merges a node with its right sibling, moving all of the values and the
+        // delimiting key in the parent node onto itself.
+        void merge(btree_node *sibling, allocator_type *alloc);
+
+        // Swap the contents of "this" and "src".
+        void swap(btree_node *src, allocator_type *alloc);
+
+        // Node allocation/deletion routines.
+        static btree_node *init_leaf(btree_node *n, btree_node *parent,
+                                     int max_cnt) {
+            n->set_parent(parent);
+            n->set_position(0);
+            n->set_start(0);
+            n->set_count(0);
+            n->set_max_count((field_type)max_cnt);
+            phmap::priv::SanitizerPoisonMemoryRegion(
+                n->slot(0), max_cnt * sizeof(slot_type));
+            return n;
+        }
+        static btree_node *init_internal(btree_node *n, btree_node *parent) {
+            init_leaf(n, parent, kNodeValues);
+            // Set `max_count` to a sentinel value to indicate that this node is
+            // internal.
+            n->set_max_count(kInternalNodeMaxCount);
+            phmap::priv::SanitizerPoisonMemoryRegion(
+                &n->mutable_child(0), (kNodeValues + 1) * sizeof(btree_node *));
+            return n;
+        }
+        void destroy(allocator_type *alloc) {
+            for (int i = 0; i < count(); ++i) {
+                value_destroy(i, alloc);
+            }
+        }
+
+    public:
+        // Exposed only for tests.
+        static bool testonly_uses_linear_node_search() {
+            return use_linear_search::value;
+        }
+
+    private:
+        template <typename... Args>
+        void value_init(const size_type i, allocator_type *alloc, Args &&... args) {
+            phmap::priv::SanitizerUnpoisonObject(slot(i));
+            params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
+        }
+        void value_destroy(const size_type i, allocator_type *alloc) {
+            params_type::destroy(alloc, slot(i));
+            phmap::priv::SanitizerPoisonObject(slot(i));
+        }
+
+        // Move n values starting at value i in this node into the values starting at
+        // value j in node x.
+        void uninitialized_move_n(const size_type n, const size_type i,
+                                  const size_type j, btree_node *x,
+                                  allocator_type *alloc) {
+            phmap::priv::SanitizerUnpoisonMemoryRegion(
+                x->slot(j), n * sizeof(slot_type));
+            for (slot_type *src = slot(i), *end = src + n, *dest = x->slot(j);
+                 src != end; ++src, ++dest) {
+                params_type::construct(alloc, dest, src);
+            }
+        }
+
+        // Destroys a range of n values, starting at index i.
+        void value_destroy_n(const size_type i, const size_type n,
+                             allocator_type *alloc) {
+            for (size_type j = 0; j < n; ++j) {
+                value_destroy(i + j, alloc);
+            }
+        }
+
+        template <typename P>
+        friend class btree;
+        template <typename N, typename R, typename P>
+        friend struct btree_iterator;
+        friend class BtreeNodePeer;
+    };
+
+    template <typename Node, typename Reference, typename Pointer>
+    struct btree_iterator {
+    private:
+        using key_type = typename Node::key_type;
+        using size_type = typename Node::size_type;
+        using params_type = typename Node::params_type;
+
+        using node_type = Node;
+        using normal_node = typename std::remove_const<Node>::type;
+        using const_node = const Node;
+        using normal_pointer = typename params_type::pointer;
+        using normal_reference = typename params_type::reference;
+        using const_pointer = typename params_type::const_pointer;
+        using const_reference = typename params_type::const_reference;
+        using slot_type = typename params_type::slot_type;
+
+        using iterator =
+            btree_iterator<normal_node, normal_reference, normal_pointer>;
+        using const_iterator =
+            btree_iterator<const_node, const_reference, const_pointer>;
+
+    public:
+        // These aliases are public for std::iterator_traits.
+        using difference_type = typename Node::difference_type;
+        using value_type = typename params_type::value_type;
+        using pointer = Pointer;
+        using reference = Reference;
+        using iterator_category = std::bidirectional_iterator_tag;
+
+        btree_iterator() : node(nullptr), position(-1) {}
+        btree_iterator(Node *n, int p) : node(n), position(p) {}
+
+        // NOTE: this SFINAE allows for implicit conversions from iterator to
+        // const_iterator, but it specifically avoids defining copy constructors so
+        // that btree_iterator can be trivially copyable. This is for performance and
+        // binary size reasons.
+        template <typename N, typename R, typename P,
+                  phmap::enable_if_t<
+                      std::is_same<btree_iterator<N, R, P>, iterator>::value &&
+                      std::is_same<btree_iterator, const_iterator>::value,
+                      int> = 0>
+            btree_iterator(const btree_iterator<N, R, P> &x)  // NOLINT
+            : node(x.node), position(x.position) {}
+
+    private:
+        // This SFINAE allows explicit conversions from const_iterator to
+        // iterator, but also avoids defining a copy constructor.
+        // NOTE: the const_cast is safe because this constructor is only called by
+        // non-const methods and the container owns the nodes.
+        template <typename N, typename R, typename P,
+                  phmap::enable_if_t<
+                      std::is_same<btree_iterator<N, R, P>, const_iterator>::value &&
+                      std::is_same<btree_iterator, iterator>::value,
+                      int> = 0>
+            explicit btree_iterator(const btree_iterator<N, R, P> &x)
+            : node(const_cast<node_type *>(x.node)), position(x.position) {}
+
+        // Increment/decrement the iterator.
+        void increment() {
+            if (node->leaf() && ++position < node->count()) {
+                return;
+            }
+            increment_slow();
+        }
+        void increment_slow();
+
+        void decrement() {
+            if (node->leaf() && --position >= 0) {
+                return;
+            }
+            decrement_slow();
+        }
+        void decrement_slow();
+
+    public:
+        bool operator==(const const_iterator &x) const {
+            return node == x.node && position == x.position;
+        }
+        bool operator!=(const const_iterator &x) const {
+            return node != x.node || position != x.position;
+        }
+        bool operator==(const iterator &x) const {
+            return node == x.node && position == x.position;
+        }
+        bool operator!=(const iterator &x) const {
+            return node != x.node || position != x.position;
+        }
+
+        // Accessors for the key/value the iterator is pointing at.
+        reference operator*() const {
+            return node->value(position);
+        }
+        pointer operator->() const {
+            return &node->value(position);
+        }
+
+        btree_iterator& operator++() {
+            increment();
+            return *this;
+        }
+        btree_iterator& operator--() {
+            decrement();
+            return *this;
+        }
+        btree_iterator operator++(int) {
+            btree_iterator tmp = *this;
+            ++*this;
+            return tmp;
+        }
+        btree_iterator operator--(int) {
+            btree_iterator tmp = *this;
+            --*this;
+            return tmp;
+        }
+
+    private:
+        template <typename Params>
+        friend class btree;
+        template <typename Tree>
+        friend class btree_container;
+        template <typename Tree>
+        friend class btree_set_container;
+        template <typename Tree>
+        friend class btree_map_container;
+        template <typename Tree>
+        friend class btree_multiset_container;
+        template <typename N, typename R, typename P>
+        friend struct btree_iterator;
+        template <typename TreeType, typename CheckerType>
+        friend class base_checker;
+
+        const key_type &key() const { return node->key(position); }
+        slot_type *slot() { return node->slot(position); }
+
+        // The node in the tree the iterator is pointing at.
+        Node *node;
+        // The position within the node of the tree the iterator is pointing at.
+        // TODO(ezb): make this a field_type
+        int position;
+    };
+
+    template <typename Params>
+    class btree {
+        using node_type = btree_node<Params>;
+        using is_key_compare_to = typename Params::is_key_compare_to;
+
+        // We use a static empty node for the root/leftmost/rightmost of empty btrees
+        // in order to avoid branching in begin()/end().
+        struct alignas(node_type::Alignment()) EmptyNodeType : node_type {
+            using field_type = typename node_type::field_type;
+            node_type *parent;
+            field_type position = 0;
+            field_type start = 0;
+            field_type count = 0;
+            // max_count must be != kInternalNodeMaxCount (so that this node is regarded
+            // as a leaf node). max_count() is never called when the tree is empty.
+            field_type max_count = node_type::kInternalNodeMaxCount + 1;
+
+#ifdef _MSC_VER
+            // MSVC has constexpr code generations bugs here.
+            EmptyNodeType() : parent(this) {}
+#else
+            constexpr EmptyNodeType(node_type *p) : parent(p) {}
+#endif
+        };
+
+        static node_type *EmptyNode() {
+#ifdef _MSC_VER
+            static EmptyNodeType empty_node;
+            // This assert fails on some other construction methods.
+            assert(empty_node.parent == &empty_node);
+            return &empty_node;
+#else
+            static constexpr EmptyNodeType empty_node(
+                const_cast<EmptyNodeType *>(&empty_node));
+            return const_cast<EmptyNodeType *>(&empty_node);
+#endif
+        }
+
+        enum {
+            kNodeValues = node_type::kNodeValues,
+            kMinNodeValues = kNodeValues / 2,
+        };
+
+        struct node_stats {
+            using size_type = typename Params::size_type;
+
+            node_stats(size_type l, size_type i)
+                : leaf_nodes(l),
+                  internal_nodes(i) {
+            }
+
+            node_stats& operator+=(const node_stats &x) {
+                leaf_nodes += x.leaf_nodes;
+                internal_nodes += x.internal_nodes;
+                return *this;
+            }
+
+            size_type leaf_nodes;
+            size_type internal_nodes;
+        };
+
+    public:
+        using key_type = typename Params::key_type;
+        using value_type = typename Params::value_type;
+        using size_type = typename Params::size_type;
+        using difference_type = typename Params::difference_type;
+        using key_compare = typename Params::key_compare;
+        using value_compare = typename Params::value_compare;
+        using allocator_type = typename Params::allocator_type;
+        using reference = typename Params::reference;
+        using const_reference = typename Params::const_reference;
+        using pointer = typename Params::pointer;
+        using const_pointer = typename Params::const_pointer;
+        using iterator = btree_iterator<node_type, reference, pointer>;
+        using const_iterator = typename iterator::const_iterator;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using node_handle_type = node_handle<Params, Params, allocator_type>;
+
+        // Internal types made public for use by btree_container types.
+        using params_type = Params;
+        using slot_type = typename Params::slot_type;
+
+    private:
+        // For use in copy_or_move_values_in_order.
+        const value_type &maybe_move_from_iterator(const_iterator x) { return *x; }
+        value_type &&maybe_move_from_iterator(iterator x) { return std::move(*x); }
+
+        // Copies or moves (depending on the template parameter) the values in
+        // x into this btree in their order in x. This btree must be empty before this
+        // method is called. This method is used in copy construction, copy
+        // assignment, and move assignment.
+        template <typename Btree>
+        void copy_or_move_values_in_order(Btree *x);
+
+        // Validates that various assumptions/requirements are true at compile time.
+        constexpr static bool static_assert_validation();
+
+    public:
+        btree(const key_compare &comp, const allocator_type &alloc);
+
+        btree(const btree &x);
+        btree(btree &&x) noexcept
+            : root_(std::move(x.root_)),
+            rightmost_(phmap::exchange(x.rightmost_, EmptyNode())),
+            size_(phmap::exchange(x.size_, 0)) {
+            x.mutable_root() = EmptyNode();
+        }
+
+        ~btree() {
+            // Put static_asserts in destructor to avoid triggering them before the type
+            // is complete.
+            static_assert(static_assert_validation(), "This call must be elided.");
+            clear();
+        }
+
+        // Assign the contents of x to *this.
+        btree &operator=(const btree &x);
+        btree &operator=(btree &&x) noexcept;
+
+        iterator begin() {
+            return iterator(leftmost(), 0);
+        }
+        const_iterator begin() const {
+            return const_iterator(leftmost(), 0);
+        }
+        iterator end() { return iterator(rightmost_, rightmost_->count()); }
+        const_iterator end() const {
+            return const_iterator(rightmost_, rightmost_->count());
+        }
+        reverse_iterator rbegin() {
+            return reverse_iterator(end());
+        }
+        const_reverse_iterator rbegin() const {
+            return const_reverse_iterator(end());
+        }
+        reverse_iterator rend() {
+            return reverse_iterator(begin());
+        }
+        const_reverse_iterator rend() const {
+            return const_reverse_iterator(begin());
+        }
+
+        // Finds the first element whose key is not less than key.
+        template <typename K>
+        iterator lower_bound(const K &key) {
+            return internal_end(internal_lower_bound(key));
+        }
+        template <typename K>
+        const_iterator lower_bound(const K &key) const {
+            return internal_end(internal_lower_bound(key));
+        }
+
+        // Finds the first element whose key is greater than key.
+        template <typename K>
+        iterator upper_bound(const K &key) {
+            return internal_end(internal_upper_bound(key));
+        }
+        template <typename K>
+        const_iterator upper_bound(const K &key) const {
+            return internal_end(internal_upper_bound(key));
+        }
+
+        // Finds the range of values which compare equal to key. The first member of
+        // the returned pair is equal to lower_bound(key). The second member pair of
+        // the pair is equal to upper_bound(key).
+        template <typename K>
+        std::pair<iterator, iterator> equal_range(const K &key) {
+            return {lower_bound(key), upper_bound(key)};
+        }
+        template <typename K>
+        std::pair<const_iterator, const_iterator> equal_range(const K &key) const {
+            return {lower_bound(key), upper_bound(key)};
+        }
+
+        // Inserts a value into the btree only if it does not already exist. The
+        // boolean return value indicates whether insertion succeeded or failed.
+        // Requirement: if `key` already exists in the btree, does not consume `args`.
+        // Requirement: `key` is never referenced after consuming `args`.
+        template <typename... Args>
+        std::pair<iterator, bool> insert_unique(const key_type &key, Args &&... args);
+
+        // Inserts with hint. Checks to see if the value should be placed immediately
+        // before `position` in the tree. If so, then the insertion will take
+        // amortized constant time. If not, the insertion will take amortized
+        // logarithmic time as if a call to insert_unique() were made.
+        // Requirement: if `key` already exists in the btree, does not consume `args`.
+        // Requirement: `key` is never referenced after consuming `args`.
+        template <typename... Args>
+        std::pair<iterator, bool> insert_hint_unique(iterator position,
+                                                     const key_type &key,
+                                                     Args &&... args);
+
+        // Insert a range of values into the btree.
+        template <typename InputIterator>
+        void insert_iterator_unique(InputIterator b, InputIterator e);
+
+        // Inserts a value into the btree.
+        template <typename ValueType>
+        iterator insert_multi(const key_type &key, ValueType &&v);
+
+        // Inserts a value into the btree.
+        template <typename ValueType>
+        iterator insert_multi(ValueType &&v) {
+            return insert_multi(params_type::key(v), std::forward<ValueType>(v));
+        }
+
+        // Insert with hint. Check to see if the value should be placed immediately
+        // before position in the tree. If it does, then the insertion will take
+        // amortized constant time. If not, the insertion will take amortized
+        // logarithmic time as if a call to insert_multi(v) were made.
+        template <typename ValueType>
+        iterator insert_hint_multi(iterator position, ValueType &&v);
+
+        // Insert a range of values into the btree.
+        template <typename InputIterator>
+        void insert_iterator_multi(InputIterator b, InputIterator e);
+
+        // Erase the specified iterator from the btree. The iterator must be valid
+        // (i.e. not equal to end()).  Return an iterator pointing to the node after
+        // the one that was erased (or end() if none exists).
+        // Requirement: does not read the value at `*iter`.
+        iterator erase(iterator iter);
+
+        // Erases range. Returns the number of keys erased and an iterator pointing
+        // to the element after the last erased element.
+        std::pair<size_type, iterator> erase(iterator begin, iterator end);
+
+        // Erases the specified key from the btree. Returns 1 if an element was
+        // erased and 0 otherwise.
+        template <typename K>
+        size_type erase_unique(const K &key);
+
+        // Erases all of the entries matching the specified key from the
+        // btree. Returns the number of elements erased.
+        template <typename K>
+        size_type erase_multi(const K &key);
+
+        // Finds the iterator corresponding to a key or returns end() if the key is
+        // not present.
+        template <typename K>
+        iterator find(const K &key) {
+            return internal_end(internal_find(key));
+        }
+        template <typename K>
+        const_iterator find(const K &key) const {
+            return internal_end(internal_find(key));
+        }
+
+        // Returns a count of the number of times the key appears in the btree.
+        template <typename K>
+        size_type count_unique(const K &key) const {
+            const iterator beg = internal_find(key);
+            if (beg.node == nullptr) {
+                // The key doesn't exist in the tree.
+                return 0;
+            }
+            return 1;
+        }
+        // Returns a count of the number of times the key appears in the btree.
+        template <typename K>
+        size_type count_multi(const K &key) const {
+            const auto range = equal_range(key);
+            return std::distance(range.first, range.second);
+        }
+
+        // Clear the btree, deleting all of the values it contains.
+        void clear();
+
+        // Swap the contents of *this and x.
+        void swap(btree &x);
+
+        const key_compare &key_comp() const noexcept {
+            return root_.template get<0>();
+        }
+        template <typename K, typename LK>
+        bool compare_keys(const K &x, const LK &y) const {
+            return compare_internal::compare_result_as_less_than(key_comp()(x, y));
+        }
+
+        value_compare value_comp() const { return value_compare(key_comp()); }
+
+        // Verifies the structure of the btree.
+        void verify() const;
+
+        // Size routines.
+        size_type size() const { return size_; }
+        size_type max_size() const { return (std::numeric_limits<size_type>::max)(); }
+        bool empty() const { return size_ == 0; }
+
+        // The height of the btree. An empty tree will have height 0.
+        size_type height() const {
+            size_type h = 0;
+            if (!empty()) {
+                // Count the length of the chain from the leftmost node up to the
+                // root. We actually count from the root back around to the level below
+                // the root, but the calculation is the same because of the circularity
+                // of that traversal.
+                const node_type *n = root();
+                do {
+                    ++h;
+                    n = n->parent();
+                } while (n != root());
+            }
+            return h;
+        }
+
+        // The number of internal, leaf and total nodes used by the btree.
+        size_type leaf_nodes() const {
+            return internal_stats(root()).leaf_nodes;
+        }
+        size_type internal_nodes() const {
+            return internal_stats(root()).internal_nodes;
+        }
+        size_type nodes() const {
+            node_stats stats = internal_stats(root());
+            return stats.leaf_nodes + stats.internal_nodes;
+        }
+
+        // The total number of bytes used by the btree.
+        size_type bytes_used() const {
+            node_stats stats = internal_stats(root());
+            if (stats.leaf_nodes == 1 && stats.internal_nodes == 0) {
+                return sizeof(*this) +
+                    node_type::LeafSize(root()->max_count());
+            } else {
+                return sizeof(*this) +
+                    stats.leaf_nodes * node_type::LeafSize() +
+                    stats.internal_nodes * node_type::InternalSize();
+            }
+        }
+
+        // The average number of bytes used per value stored in the btree.
+        static double average_bytes_per_value() {
+            // Returns the number of bytes per value on a leaf node that is 75%
+            // full. Experimentally, this matches up nicely with the computed number of
+            // bytes per value in trees that had their values inserted in random order.
+            return node_type::LeafSize() / (kNodeValues * 0.75);
+        }
+
+        // The fullness of the btree. Computed as the number of elements in the btree
+        // divided by the maximum number of elements a tree with the current number
+        // of nodes could hold. A value of 1 indicates perfect space
+        // utilization. Smaller values indicate space wastage.
+        // Returns 0 for empty trees.
+        double fullness() const {
+            if (empty()) return 0.0;
+            return static_cast<double>(size()) / (nodes() * kNodeValues);
+        }
+        // The overhead of the btree structure in bytes per node. Computed as the
+        // total number of bytes used by the btree minus the number of bytes used for
+        // storing elements divided by the number of elements.
+        // Returns 0 for empty trees.
+        double overhead() const {
+            if (empty()) return 0.0;
+            return (bytes_used() - size() * sizeof(value_type)) /
+                static_cast<double>(size());
+        }
+
+        // The allocator used by the btree.
+        allocator_type get_allocator() const {
+            return allocator();
+        }
+
+    private:
+        // Internal accessor routines.
+        node_type *root() { return root_.template get<2>(); }
+        const node_type *root() const { return root_.template get<2>(); }
+        node_type *&mutable_root() noexcept { return root_.template get<2>(); }
+        key_compare *mutable_key_comp() noexcept { return &root_.template get<0>(); }
+
+        // The leftmost node is stored as the parent of the root node.
+        node_type *leftmost() { return root()->parent(); }
+        const node_type *leftmost() const { return root()->parent(); }
+
+        // Allocator routines.
+        allocator_type *mutable_allocator() noexcept {
+            return &root_.template get<1>();
+        }
+        const allocator_type &allocator() const noexcept {
+            return root_.template get<1>();
+        }
+
+        // Allocates a correctly aligned node of at least size bytes using the
+        // allocator.
+        node_type *allocate(const size_type sz) {
+            return reinterpret_cast<node_type *>(
+                phmap::priv::Allocate<node_type::Alignment()>(
+                    mutable_allocator(), (size_t)sz));
+        }
+
+        // Node creation/deletion routines.
+        node_type* new_internal_node(node_type *parent) {
+            node_type *p = allocate(node_type::InternalSize());
+            return node_type::init_internal(p, parent);
+        }
+        node_type* new_leaf_node(node_type *parent) {
+            node_type *p = allocate(node_type::LeafSize());
+            return node_type::init_leaf(p, parent, kNodeValues);
+        }
+        node_type *new_leaf_root_node(const int max_count) {
+            node_type *p = allocate(node_type::LeafSize(max_count));
+            return node_type::init_leaf(p, p, max_count);
+        }
+
+        // Deletion helper routines.
+        void erase_same_node(iterator begin, iterator end);
+        iterator erase_from_leaf_node(iterator begin, size_type to_erase);
+        iterator rebalance_after_delete(iterator iter);
+
+        // Deallocates a node of a certain size in bytes using the allocator.
+        void deallocate(const size_type sz, node_type *node) {
+            phmap::priv::Deallocate<node_type::Alignment()>(
+                mutable_allocator(), node, (size_t)sz);
+        }
+
+        void delete_internal_node(node_type *node) {
+            node->destroy(mutable_allocator());
+            deallocate(node_type::InternalSize(), node);
+        }
+        void delete_leaf_node(node_type *node) {
+            node->destroy(mutable_allocator());
+            deallocate(node_type::LeafSize(node->max_count()), node);
+        }
+
+        // Rebalances or splits the node iter points to.
+        void rebalance_or_split(iterator *iter);
+
+        // Merges the values of left, right and the delimiting key on their parent
+        // onto left, removing the delimiting key and deleting right.
+        void merge_nodes(node_type *left, node_type *right);
+
+        // Tries to merge node with its left or right sibling, and failing that,
+        // rebalance with its left or right sibling. Returns true if a merge
+        // occurred, at which point it is no longer valid to access node. Returns
+        // false if no merging took place.
+        bool try_merge_or_rebalance(iterator *iter);
+
+        // Tries to shrink the height of the tree by 1.
+        void try_shrink();
+
+        iterator internal_end(iterator iter) {
+            return iter.node != nullptr ? iter : end();
+        }
+        const_iterator internal_end(const_iterator iter) const {
+            return iter.node != nullptr ? iter : end();
+        }
+
+        // Emplaces a value into the btree immediately before iter. Requires that
+        // key(v) <= iter.key() and (--iter).key() <= key(v).
+        template <typename... Args>
+        iterator internal_emplace(iterator iter, Args &&... args);
+
+        // Returns an iterator pointing to the first value >= the value "iter" is
+        // pointing at. Note that "iter" might be pointing to an invalid location as
+        // iter.position == iter.node->count(). This routine simply moves iter up in
+        // the tree to a valid location.
+        // Requires: iter.node is non-null.
+        template <typename IterType>
+        static IterType internal_last(IterType iter);
+
+        // Returns an iterator pointing to the leaf position at which key would
+        // reside in the tree. We provide 2 versions of internal_locate. The first
+        // version uses a less-than comparator and is incapable of distinguishing when
+        // there is an exact match. The second version is for the key-compare-to
+        // specialization and distinguishes exact matches. The key-compare-to
+        // specialization allows the caller to avoid a subsequent comparison to
+        // determine if an exact match was made, which is important for keys with
+        // expensive comparison, such as strings.
+        template <typename K>
+        SearchResult<iterator, is_key_compare_to::value> internal_locate(
+            const K &key) const;
+
+        template <typename K>
+        SearchResult<iterator, false> internal_locate_impl(
+            const K &key, std::false_type /* IsCompareTo */) const;
+
+        template <typename K>
+        SearchResult<iterator, true> internal_locate_impl(
+            const K &key, std::true_type /* IsCompareTo */) const;
+
+        // Internal routine which implements lower_bound().
+        template <typename K>
+        iterator internal_lower_bound(const K &key) const;
+
+        // Internal routine which implements upper_bound().
+        template <typename K>
+        iterator internal_upper_bound(const K &key) const;
+
+        // Internal routine which implements find().
+        template <typename K>
+        iterator internal_find(const K &key) const;
+
+        // Deletes a node and all of its children.
+        void internal_clear(node_type *node);
+
+        // Verifies the tree structure of node.
+        size_type internal_verify(const node_type *node,
+                                  const key_type *lo, const key_type *hi) const;
+
+        node_stats internal_stats(const node_type *node) const {
+            // The root can be a static empty node.
+            if (node == nullptr || (node == root() && empty())) {
+                return node_stats(0, 0);
+            }
+            if (node->leaf()) {
+                return node_stats(1, 0);
+            }
+            node_stats res(0, 1);
+            for (int i = 0; i <= node->count(); ++i) {
+                res += internal_stats(node->child(i));
+            }
+            return res;
+        }
+
+    public:
+        // Exposed only for tests.
+        static bool testonly_uses_linear_node_search() {
+            return node_type::testonly_uses_linear_node_search();
+        }
+
+    private:
+        // We use compressed tuple in order to save space because key_compare and
+        // allocator_type are usually empty.
+        phmap::priv::CompressedTuple<key_compare, allocator_type,
+                                                    node_type *>
+        root_;
+
+        // A pointer to the rightmost node. Note that the leftmost node is stored as
+        // the root's parent.
+        node_type *rightmost_;
+
+        // Number of values.
+        size_type size_;
+    };
+
+    ////
+    // btree_node methods
+    template <typename P>
+    template <typename... Args>
+    inline void btree_node<P>::emplace_value(const size_type i,
+                                             allocator_type *alloc,
+                                             Args &&... args) {
+        assert(i <= count());
+        // Shift old values to create space for new value and then construct it in
+        // place.
+        if (i < count()) {
+            value_init(count(), alloc, slot(count() - 1));
+            for (size_type j = count() - 1; j > i; --j)
+                params_type::move(alloc, slot(j - 1), slot(j));
+            value_destroy(i, alloc);
+        }
+        value_init(i, alloc, std::forward<Args>(args)...);
+        set_count((field_type)(count() + 1));
+
+        if (!leaf() && count() > i + 1) {
+            for (int j = count(); j > (int)(i + 1); --j) {
+                set_child(j, child(j - 1));
+            }
+            clear_child(i + 1);
+        }
+    }
+
+    template <typename P>
+    inline void btree_node<P>::remove_value(const int i, allocator_type *alloc) {
+        if (!leaf() && count() > i + 1) {
+            assert(child(i + 1)->count() == 0);
+            for (size_type j = i + 1; j < count(); ++j) {
+                set_child(j, child(j + 1));
+            }
+            clear_child(count());
+        }
+
+        remove_values_ignore_children(i, /*to_erase=*/1, alloc);
+    }
+
+    template <typename P>
+    inline void btree_node<P>::remove_values_ignore_children(
+        int i, size_type to_erase, allocator_type *alloc) {
+        params_type::move(alloc, slot(i + to_erase), slot(count()), slot(i));
+        value_destroy_n(count() - to_erase, to_erase, alloc);
+        set_count((field_type)(count() - to_erase));
+    }
+
+    template <typename P>
+    void btree_node<P>::rebalance_right_to_left(const int to_move,
+                                                btree_node *right,
+                                                allocator_type *alloc) {
+        assert(parent() == right->parent());
+        assert(position() + 1 == right->position());
+        assert(right->count() >= count());
+        assert(to_move >= 1);
+        assert(to_move <= right->count());
+
+        // 1) Move the delimiting value in the parent to the left node.
+        value_init(count(), alloc, parent()->slot(position()));
+
+        // 2) Move the (to_move - 1) values from the right node to the left node.
+        right->uninitialized_move_n(to_move - 1, 0, count() + 1, this, alloc);
+
+        // 3) Move the new delimiting value to the parent from the right node.
+        params_type::move(alloc, right->slot(to_move - 1),
+                          parent()->slot(position()));
+
+        // 4) Shift the values in the right node to their correct position.
+        params_type::move(alloc, right->slot(to_move), right->slot(right->count()),
+                          right->slot(0));
+
+        // 5) Destroy the now-empty to_move entries in the right node.
+        right->value_destroy_n(right->count() - to_move, to_move, alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the right to the left node.
+            for (int i = 0; i < to_move; ++i) {
+                init_child(count() + i + 1, right->child(i));
+            }
+            for (int i = 0; i <= right->count() - to_move; ++i) {
+                assert(i + to_move <= right->max_count());
+                right->init_child(i, right->child(i + to_move));
+                right->clear_child(i + to_move);
+            }
+        }
+
+        // Fixup the counts on the left and right nodes.
+        set_count((field_type)(count() + to_move));
+        right->set_count((field_type)(right->count() - to_move));
+    }
+
+    template <typename P>
+    void btree_node<P>::rebalance_left_to_right(const int to_move,
+                                                btree_node *right,
+                                                allocator_type *alloc) {
+        assert(parent() == right->parent());
+        assert(position() + 1 == right->position());
+        assert(count() >= right->count());
+        assert(to_move >= 1);
+        assert(to_move <= count());
+
+        // Values in the right node are shifted to the right to make room for the
+        // new to_move values. Then, the delimiting value in the parent and the
+        // other (to_move - 1) values in the left node are moved into the right node.
+        // Lastly, a new delimiting value is moved from the left node into the
+        // parent, and the remaining empty left node entries are destroyed.
+
+        if (right->count() >= to_move) {
+            // The original location of the right->count() values are sufficient to hold
+            // the new to_move entries from the parent and left node.
+
+            // 1) Shift existing values in the right node to their correct positions.
+            right->uninitialized_move_n(to_move, right->count() - to_move,
+                                        right->count(), right, alloc);
+            if (right->count() > to_move) {
+                for (slot_type *src = right->slot(right->count() - to_move - 1),
+                         *dest = right->slot(right->count() - 1),
+                         *end = right->slot(0);
+                     src >= end; --src, --dest) {
+                    params_type::move(alloc, src, dest);
+                }
+            }
+
+            // 2) Move the delimiting value in the parent to the right node.
+            params_type::move(alloc, parent()->slot(position()),
+                              right->slot(to_move - 1));
+
+            // 3) Move the (to_move - 1) values from the left node to the right node.
+            params_type::move(alloc, slot(count() - (to_move - 1)), slot(count()),
+                              right->slot(0));
+        } else {
+            // The right node does not have enough initialized space to hold the new
+            // to_move entries, so part of them will move to uninitialized space.
+
+            // 1) Shift existing values in the right node to their correct positions.
+            right->uninitialized_move_n(right->count(), 0, to_move, right, alloc);
+
+            // 2) Move the delimiting value in the parent to the right node.
+            right->value_init(to_move - 1, alloc, parent()->slot(position()));
+
+            // 3) Move the (to_move - 1) values from the left node to the right node.
+            const size_type uninitialized_remaining = to_move - right->count() - 1;
+            uninitialized_move_n(uninitialized_remaining,
+                                 count() - uninitialized_remaining, right->count(),
+                                 right, alloc);
+            params_type::move(alloc, slot(count() - (to_move - 1)),
+                              slot(count() - uninitialized_remaining), right->slot(0));
+        }
+
+        // 4) Move the new delimiting value to the parent from the left node.
+        params_type::move(alloc, slot(count() - to_move), parent()->slot(position()));
+
+        // 5) Destroy the now-empty to_move entries in the left node.
+        value_destroy_n(count() - to_move, to_move, alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the left to the right node.
+            for (int i = right->count(); i >= 0; --i) {
+                right->init_child(i + to_move, right->child(i));
+                right->clear_child(i);
+            }
+            for (int i = 1; i <= to_move; ++i) {
+                right->init_child(i - 1, child(count() - to_move + i));
+                clear_child(count() - to_move + i);
+            }
+        }
+
+        // Fixup the counts on the left and right nodes.
+        set_count((field_type)(count() - to_move));
+        right->set_count((field_type)(right->count() + to_move));
+    }
+
+    template <typename P>
+    void btree_node<P>::split(const int insert_position, btree_node *dest,
+                              allocator_type *alloc) {
+        assert(dest->count() == 0);
+        assert(max_count() == kNodeValues);
+
+        // We bias the split based on the position being inserted. If we're
+        // inserting at the beginning of the left node then bias the split to put
+        // more values on the right node. If we're inserting at the end of the
+        // right node then bias the split to put more values on the left node.
+        if (insert_position == 0) {
+            dest->set_count((field_type)(count() - 1));
+        } else if (insert_position == kNodeValues) {
+            dest->set_count(0);
+        } else {
+            dest->set_count((field_type)(count() / 2));
+        }
+        set_count((field_type)(count() - dest->count()));
+        assert(count() >= 1);
+
+        // Move values from the left sibling to the right sibling.
+        uninitialized_move_n(dest->count(), count(), 0, dest, alloc);
+
+        // Destroy the now-empty entries in the left node.
+        value_destroy_n(count(), dest->count(), alloc);
+
+        // The split key is the largest value in the left sibling.
+        set_count((field_type)(count() - 1));
+        parent()->emplace_value(position(), alloc, slot(count()));
+        value_destroy(count(), alloc);
+        parent()->init_child(position() + 1, dest);
+
+        if (!leaf()) {
+            for (int i = 0; i <= dest->count(); ++i) {
+                assert(child(count() + i + 1) != nullptr);
+                dest->init_child(i, child(count() + i + 1));
+                clear_child(count() + i + 1);
+            }
+        }
+    }
+
+    template <typename P>
+    void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
+        assert(parent() == src->parent());
+        assert(position() + 1 == src->position());
+
+        // Move the delimiting value to the left node.
+        value_init(count(), alloc, parent()->slot(position()));
+
+        // Move the values from the right to the left node.
+        src->uninitialized_move_n(src->count(), 0, count() + 1, this, alloc);
+
+        // Destroy the now-empty entries in the right node.
+        src->value_destroy_n(0, src->count(), alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the right to the left node.
+            for (int i = 0; i <= src->count(); ++i) {
+                init_child(count() + i + 1, src->child(i));
+                src->clear_child(i);
+            }
+        }
+
+        // Fixup the counts on the src and dest nodes.
+        set_count((field_type)(1 + count() + src->count()));
+        src->set_count(0);
+
+        // Remove the value on the parent node.
+        parent()->remove_value(position(), alloc);
+    }
+
+    template <typename P>
+    void btree_node<P>::swap(btree_node *x, allocator_type *alloc) {
+        using std::swap;
+        assert(leaf() == x->leaf());
+
+        // Determine which is the smaller/larger node.
+        btree_node *smaller = this, *larger = x;
+        if (smaller->count() > larger->count()) {
+            swap(smaller, larger);
+        }
+
+        // Swap the values.
+        for (slot_type *a = smaller->slot(0), *b = larger->slot(0),
+                 *end = a + smaller->count();
+             a != end; ++a, ++b) {
+            params_type::swap(alloc, a, b);
+        }
+
+        // Move values that can't be swapped.
+        const size_type to_move = larger->count() - smaller->count();
+        larger->uninitialized_move_n(to_move, smaller->count(), smaller->count(),
+                                     smaller, alloc);
+        larger->value_destroy_n(smaller->count(), to_move, alloc);
+
+        if (!leaf()) {
+            // Swap the child pointers.
+            std::swap_ranges(&smaller->mutable_child(0),
+                             &smaller->mutable_child(smaller->count() + 1),
+                             &larger->mutable_child(0));
+            // Update swapped children's parent pointers.
+            int i = 0;
+            for (; i <= smaller->count(); ++i) {
+                smaller->child(i)->set_parent(smaller);
+                larger->child(i)->set_parent(larger);
+            }
+            // Move the child pointers that couldn't be swapped.
+            for (; i <= larger->count(); ++i) {
+                smaller->init_child(i, larger->child(i));
+                larger->clear_child(i);
+            }
+        }
+
+        // Swap the counts.
+        swap(mutable_count(), x->mutable_count());
+    }
+
+    ////
+    // btree_iterator methods
+    template <typename N, typename R, typename P>
+    void btree_iterator<N, R, P>::increment_slow() {
+        if (node->leaf()) {
+            assert(position >= node->count());
+            btree_iterator save(*this);
+            while (position == node->count() && !node->is_root()) {
+                assert(node->parent()->child(node->position()) == node);
+                position = node->position();
+                node = node->parent();
+            }
+            if (position == node->count()) {
+                *this = save;
+            }
+        } else {
+            assert(position < node->count());
+            node = node->child(position + 1);
+            while (!node->leaf()) {
+                node = node->child(0);
+            }
+            position = 0;
+        }
+    }
+
+    template <typename N, typename R, typename P>
+    void btree_iterator<N, R, P>::decrement_slow() {
+        if (node->leaf()) {
+            assert(position <= -1);
+            btree_iterator save(*this);
+            while (position < 0 && !node->is_root()) {
+                assert(node->parent()->child(node->position()) == node);
+                position = node->position() - 1;
+                node = node->parent();
+            }
+            if (position < 0) {
+                *this = save;
+            }
+        } else {
+            assert(position >= 0);
+            node = node->child(position);
+            while (!node->leaf()) {
+                node = node->child(node->count());
+            }
+            position = node->count() - 1;
+        }
+    }
+
+    ////
+    // btree methods
+    template <typename P>
+    template <typename Btree>
+    void btree<P>::copy_or_move_values_in_order(Btree *x) {
+        static_assert(std::is_same<btree, Btree>::value ||
+                      std::is_same<const btree, Btree>::value,
+                      "Btree type must be same or const.");
+        assert(empty());
+
+        // We can avoid key comparisons because we know the order of the
+        // values is the same order we'll store them in.
+        auto iter = x->begin();
+        if (iter == x->end()) return;
+        insert_multi(maybe_move_from_iterator(iter));
+        ++iter;
+        for (; iter != x->end(); ++iter) {
+            // If the btree is not empty, we can just insert the new value at the end
+            // of the tree.
+            internal_emplace(end(), maybe_move_from_iterator(iter));
+        }
+    }
+
+    template <typename P>
+    constexpr bool btree<P>::static_assert_validation() {
+        static_assert(std::is_nothrow_copy_constructible<key_compare>::value,
+                      "Key comparison must be nothrow copy constructible");
+        static_assert(std::is_nothrow_copy_constructible<allocator_type>::value,
+                      "Allocator must be nothrow copy constructible");
+        static_assert(type_traits_internal::is_trivially_copyable<iterator>::value,
+                      "iterator not trivially copyable.");
+
+        // Note: We assert that kTargetValues, which is computed from
+        // Params::kTargetNodeSize, must fit the node_type::field_type.
+        static_assert(
+            kNodeValues < (1 << (8 * sizeof(typename node_type::field_type))),
+            "target node size too large");
+
+        // Verify that key_compare returns an phmap::{weak,strong}_ordering or bool.
+        using compare_result_type =
+            phmap::invoke_result_t<key_compare, key_type, key_type>;
+        static_assert(
+            std::is_same<compare_result_type, bool>::value ||
+            std::is_convertible<compare_result_type, phmap::weak_ordering>::value,
+            "key comparison function must return phmap::{weak,strong}_ordering or "
+            "bool.");
+
+        // Test the assumption made in setting kNodeSlotSpace.
+        static_assert(node_type::MinimumOverhead() >= sizeof(void *) + 4,
+                      "node space assumption incorrect");
+
+        return true;
+    }
+
+    template <typename P>
+    btree<P>::btree(const key_compare &comp, const allocator_type &alloc)
+        : root_(comp, alloc, EmptyNode()), rightmost_(EmptyNode()), size_(0) {}
+
+    template <typename P>
+    btree<P>::btree(const btree &x) : btree(x.key_comp(), x.allocator()) {
+        copy_or_move_values_in_order(&x);
+    }
+
+    template <typename P>
+    template <typename... Args>
+    auto btree<P>::insert_unique(const key_type &key, Args &&... args)
+        -> std::pair<iterator, bool> {
+        if (empty()) {
+            mutable_root() = rightmost_ = new_leaf_root_node(1);
+        }
+
+        auto res = internal_locate(key);
+        iterator &iter = res.value;
+
+        if (res.HasMatch()) {
+            if (res.IsEq()) {
+                // The key already exists in the tree, do nothing.
+                return {iter, false};
+            }
+        } else {
+            iterator last = internal_last(iter);
+            if (last.node && !compare_keys(key, last.key())) {
+                // The key already exists in the tree, do nothing.
+                return {last, false};
+            }
+        }
+        return {internal_emplace(iter, std::forward<Args>(args)...), true};
+    }
+
+    template <typename P>
+    template <typename... Args>
+    inline auto btree<P>::insert_hint_unique(iterator position, const key_type &key,
+                                             Args &&... args)
+        -> std::pair<iterator, bool> {
+        if (!empty()) {
+            if (position == end() || compare_keys(key, position.key())) {
+                iterator prev = position;
+                if (position == begin() || compare_keys((--prev).key(), key)) {
+                    // prev.key() < key < position.key()
+                    return {internal_emplace(position, std::forward<Args>(args)...), true};
+                }
+            } else if (compare_keys(position.key(), key)) {
+                ++position;
+                if (position == end() || compare_keys(key, position.key())) {
+                    // {original `position`}.key() < key < {current `position`}.key()
+                    return {internal_emplace(position, std::forward<Args>(args)...), true};
+                }
+            } else {
+                // position.key() == key
+                return {position, false};
+            }
+        }
+        return insert_unique(key, std::forward<Args>(args)...);
+    }
+
+    template <typename P>
+    template <typename InputIterator>
+    void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e) {
+        for (; b != e; ++b) {
+            insert_hint_unique(end(), params_type::key(*b), *b);
+        }
+    }
+
+    template <typename P>
+    template <typename ValueType>
+    auto btree<P>::insert_multi(const key_type &key, ValueType &&v) -> iterator {
+        if (empty()) {
+            mutable_root() = rightmost_ = new_leaf_root_node(1);
+        }
+
+        iterator iter = internal_upper_bound(key);
+        if (iter.node == nullptr) {
+            iter = end();
+        }
+        return internal_emplace(iter, std::forward<ValueType>(v));
+    }
+
+    template <typename P>
+    template <typename ValueType>
+    auto btree<P>::insert_hint_multi(iterator position, ValueType &&v) -> iterator {
+        if (!empty()) {
+            const key_type &key = params_type::key(v);
+            if (position == end() || !compare_keys(position.key(), key)) {
+                iterator prev = position;
+                if (position == begin() || !compare_keys(key, (--prev).key())) {
+                    // prev.key() <= key <= position.key()
+                    return internal_emplace(position, std::forward<ValueType>(v));
+                }
+            } else {
+                iterator next = position;
+                ++next;
+                if (next == end() || !compare_keys(next.key(), key)) {
+                    // position.key() < key <= next.key()
+                    return internal_emplace(next, std::forward<ValueType>(v));
+                }
+            }
+        }
+        return insert_multi(std::forward<ValueType>(v));
+    }
+
+    template <typename P>
+    template <typename InputIterator>
+    void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e) {
+        for (; b != e; ++b) {
+            insert_hint_multi(end(), *b);
+        }
+    }
+
+    template <typename P>
+    auto btree<P>::operator=(const btree &x) -> btree & {
+        if (this != &x) {
+            clear();
+
+            *mutable_key_comp() = x.key_comp();
+            if (phmap::allocator_traits<
+                allocator_type>::propagate_on_container_copy_assignment::value) {
+                *mutable_allocator() = x.allocator();
+            }
+
+            copy_or_move_values_in_order(&x);
+        }
+        return *this;
+    }
+
+    template <typename P>
+    auto btree<P>::operator=(btree &&x) noexcept -> btree & {
+        if (this != &x) {
+            clear();
+
+            using std::swap;
+            if (phmap::allocator_traits<
+                allocator_type>::propagate_on_container_copy_assignment::value) {
+                // Note: `root_` also contains the allocator and the key comparator.
+                swap(root_, x.root_);
+                swap(rightmost_, x.rightmost_);
+                swap(size_, x.size_);
+            } else {
+                if (allocator() == x.allocator()) {
+                    swap(mutable_root(), x.mutable_root());
+                    swap(*mutable_key_comp(), *x.mutable_key_comp());
+                    swap(rightmost_, x.rightmost_);
+                    swap(size_, x.size_);
+                } else {
+                    // We aren't allowed to propagate the allocator and the allocator is
+                    // different so we can't take over its memory. We must move each element
+                    // individually. We need both `x` and `this` to have `x`s key comparator
+                    // while moving the values so we can't swap the key comparators.
+                    *mutable_key_comp() = x.key_comp();
+                    copy_or_move_values_in_order(&x);
+                }
+            }
+        }
+        return *this;
+    }
+
+    template <typename P>
+    auto btree<P>::erase(iterator iter) -> iterator {
+        bool internal_delete = false;
+        if (!iter.node->leaf()) {
+            // Deletion of a value on an internal node. First, move the largest value
+            // from our left child here, then delete that position (in remove_value()
+            // below). We can get to the largest value from our left child by
+            // decrementing iter.
+            iterator internal_iter(iter);
+            --iter;
+            assert(iter.node->leaf());
+            params_type::move(mutable_allocator(), iter.node->slot(iter.position),
+                              internal_iter.node->slot(internal_iter.position));
+            internal_delete = true;
+        }
+
+        // Delete the key from the leaf.
+        iter.node->remove_value(iter.position, mutable_allocator());
+        --size_;
+
+        // We want to return the next value after the one we just erased. If we
+        // erased from an internal node (internal_delete == true), then the next
+        // value is ++(++iter). If we erased from a leaf node (internal_delete ==
+        // false) then the next value is ++iter. Note that ++iter may point to an
+        // internal node and the value in the internal node may move to a leaf node
+        // (iter.node) when rebalancing is performed at the leaf level.
+
+        iterator res = rebalance_after_delete(iter);
+
+        // If we erased from an internal node, advance the iterator.
+        if (internal_delete) {
+            ++res;
+        }
+        return res;
+    }
+
+    template <typename P>
+    auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
+        // Merge/rebalance as we walk back up the tree.
+        iterator res(iter);
+        bool first_iteration = true;
+        for (;;) {
+            if (iter.node == root()) {
+                try_shrink();
+                if (empty()) {
+                    return end();
+                }
+                break;
+            }
+            if (iter.node->count() >= kMinNodeValues) {
+                break;
+            }
+            bool merged = try_merge_or_rebalance(&iter);
+            // On the first iteration, we should update `res` with `iter` because `res`
+            // may have been invalidated.
+            if (first_iteration) {
+                res = iter;
+                first_iteration = false;
+            }
+            if (!merged) {
+                break;
+            }
+            iter.position = iter.node->position();
+            iter.node = iter.node->parent();
+        }
+
+        // Adjust our return value. If we're pointing at the end of a node, advance
+        // the iterator.
+        if (res.position == res.node->count()) {
+            res.position = res.node->count() - 1;
+            ++res;
+        }
+
+        return res;
+    }
+
+    template <typename P>
+    auto btree<P>::erase(iterator _begin, iterator _end)
+        -> std::pair<size_type, iterator> {
+        difference_type count = std::distance(_begin, _end);
+        assert(count >= 0);
+
+        if (count == 0) {
+            return {0, _begin};
+        }
+
+        if (count == (difference_type)size_) {
+            clear();
+            return {count, this->end()};
+        }
+
+        if (_begin.node == _end.node) {
+            erase_same_node(_begin, _end);
+            size_ -= count;
+            return {count, rebalance_after_delete(_begin)};
+        }
+
+        const size_type target_size = size_ - count;
+        while (size_ > target_size) {
+            if (_begin.node->leaf()) {
+                const size_type remaining_to_erase = size_ - target_size;
+                const size_type remaining_in_node = _begin.node->count() - _begin.position;
+                _begin = erase_from_leaf_node(
+                    _begin, (std::min)(remaining_to_erase, remaining_in_node));
+            } else {
+                _begin = erase(_begin);
+            }
+        }
+        return {count, _begin};
+    }
+
+    template <typename P>
+    void btree<P>::erase_same_node(iterator _begin, iterator _end) {
+        assert(_begin.node == _end.node);
+        assert(_end.position > _begin.position);
+
+        node_type *node = _begin.node;
+        size_type to_erase = _end.position - _begin.position;
+        if (!node->leaf()) {
+            // Delete all children between _begin and _end.
+            for (size_type i = 0; i < to_erase; ++i) {
+                internal_clear(node->child(_begin.position + i + 1));
+            }
+            // Rotate children after _end into new positions.
+            for (size_type i = _begin.position + to_erase + 1; i <= node->count(); ++i) {
+                node->set_child(i - to_erase, node->child(i));
+                node->clear_child(i);
+            }
+        }
+        node->remove_values_ignore_children(_begin.position, to_erase,
+                                            mutable_allocator());
+
+        // Do not need to update rightmost_, because
+        // * either _end == this->end(), and therefore node == rightmost_, and still
+        //   exists
+        // * or _end != this->end(), and therefore rightmost_ hasn't been erased, since
+        //   it wasn't covered in [_begin, _end)
+    }
+
+    template <typename P>
+    auto btree<P>::erase_from_leaf_node(iterator _begin, size_type to_erase)
+        -> iterator {
+        node_type *node = _begin.node;
+        assert(node->leaf());
+        assert(node->count() > _begin.position);
+        assert(_begin.position + to_erase <= node->count());
+
+        node->remove_values_ignore_children(_begin.position, to_erase,
+                                            mutable_allocator());
+
+        size_ -= to_erase;
+
+        return rebalance_after_delete(_begin);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::erase_unique(const K &key) -> size_type {
+        const iterator iter = internal_find(key);
+        if (iter.node == nullptr) {
+            // The key doesn't exist in the tree, return nothing done.
+            return 0;
+        }
+        erase(iter);
+        return 1;
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::erase_multi(const K &key) -> size_type {
+        const iterator _begin = internal_lower_bound(key);
+        if (_begin.node == nullptr) {
+            // The key doesn't exist in the tree, return nothing done.
+            return 0;
+        }
+        // Delete all of the keys between _begin and upper_bound(key).
+        const iterator _end = internal_end(internal_upper_bound(key));
+        return erase(_begin, _end).first;
+    }
+
+    template <typename P>
+    void btree<P>::clear() {
+        if (!empty()) {
+            internal_clear(root());
+        }
+        mutable_root() = EmptyNode();
+        rightmost_ = EmptyNode();
+        size_ = 0;
+    }
+
+    template <typename P>
+    void btree<P>::swap(btree &x) {
+        using std::swap;
+        if (phmap::allocator_traits<
+            allocator_type>::propagate_on_container_swap::value) {
+            // Note: `root_` also contains the allocator and the key comparator.
+            swap(root_, x.root_);
+        } else {
+            // It's undefined behavior if the allocators are unequal here.
+            assert(allocator() == x.allocator());
+            swap(mutable_root(), x.mutable_root());
+            swap(*mutable_key_comp(), *x.mutable_key_comp());
+        }
+        swap(rightmost_, x.rightmost_);
+        swap(size_, x.size_);
+    }
+
+    template <typename P>
+    void btree<P>::verify() const {
+        assert(root() != nullptr);
+        assert(leftmost() != nullptr);
+        assert(rightmost_ != nullptr);
+        assert(empty() || size() == internal_verify(root(), nullptr, nullptr));
+        assert(leftmost() == (++const_iterator(root(), -1)).node);
+        assert(rightmost_ == (--const_iterator(root(), root()->count())).node);
+        assert(leftmost()->leaf());
+        assert(rightmost_->leaf());
+    }
+
+    template <typename P>
+    void btree<P>::rebalance_or_split(iterator *iter) {
+        node_type *&node = iter->node;
+        int &insert_position = iter->position;
+        assert(node->count() == node->max_count());
+        assert(kNodeValues == node->max_count());
+
+        // First try to make room on the node by rebalancing.
+        node_type *parent = node->parent();
+        if (node != root()) {
+            if (node->position() > 0) {
+                // Try rebalancing with our left sibling.
+                node_type *left = parent->child(node->position() - 1);
+                assert(left->max_count() == kNodeValues);
+                if (left->count() < kNodeValues) {
+                    // We bias rebalancing based on the position being inserted. If we're
+                    // inserting at the end of the right node then we bias rebalancing to
+                    // fill up the left node.
+                    int to_move = (kNodeValues - left->count()) /
+                        (1 + (insert_position < kNodeValues));
+                    to_move = (std::max)(1, to_move);
+
+                    if (((insert_position - to_move) >= 0) ||
+                        ((left->count() + to_move) < kNodeValues)) {
+                        left->rebalance_right_to_left(to_move, node, mutable_allocator());
+
+                        assert(node->max_count() - node->count() == to_move);
+                        insert_position = insert_position - to_move;
+                        if (insert_position < 0) {
+                            insert_position = insert_position + left->count() + 1;
+                            node = left;
+                        }
+
+                        assert(node->count() < node->max_count());
+                        return;
+                    }
+                }
+            }
+
+            if (node->position() < parent->count()) {
+                // Try rebalancing with our right sibling.
+                node_type *right = parent->child(node->position() + 1);
+                assert(right->max_count() == kNodeValues);
+                if (right->count() < kNodeValues) {
+                    // We bias rebalancing based on the position being inserted. If we're
+                    // inserting at the _beginning of the left node then we bias rebalancing
+                    // to fill up the right node.
+                    int to_move =
+                        (kNodeValues - right->count()) / (1 + (insert_position > 0));
+                    to_move = (std::max)(1, to_move);
+
+                    if ((insert_position <= (node->count() - to_move)) ||
+                        ((right->count() + to_move) < kNodeValues)) {
+                        node->rebalance_left_to_right(to_move, right, mutable_allocator());
+
+                        if (insert_position > node->count()) {
+                            insert_position = insert_position - node->count() - 1;
+                            node = right;
+                        }
+
+                        assert(node->count() < node->max_count());
+                        return;
+                    }
+                }
+            }
+
+            // Rebalancing failed, make sure there is room on the parent node for a new
+            // value.
+            assert(parent->max_count() == kNodeValues);
+            if (parent->count() == kNodeValues) {
+                iterator parent_iter(node->parent(), node->position());
+                rebalance_or_split(&parent_iter);
+            }
+        } else {
+            // Rebalancing not possible because this is the root node.
+            // Create a new root node and set the current root node as the child of the
+            // new root.
+            parent = new_internal_node(parent);
+            parent->init_child(0, root());
+            mutable_root() = parent;
+            // If the former root was a leaf node, then it's now the rightmost node.
+            assert(!parent->child(0)->leaf() || parent->child(0) == rightmost_);
+        }
+
+        // Split the node.
+        node_type *split_node;
+        if (node->leaf()) {
+            split_node = new_leaf_node(parent);
+            node->split(insert_position, split_node, mutable_allocator());
+            if (rightmost_ == node) rightmost_ = split_node;
+        } else {
+            split_node = new_internal_node(parent);
+            node->split(insert_position, split_node, mutable_allocator());
+        }
+
+        if (insert_position > node->count()) {
+            insert_position = insert_position - node->count() - 1;
+            node = split_node;
+        }
+    }
+
+    template <typename P>
+    void btree<P>::merge_nodes(node_type *left, node_type *right) {
+        left->merge(right, mutable_allocator());
+        if (right->leaf()) {
+            if (rightmost_ == right) rightmost_ = left;
+            delete_leaf_node(right);
+        } else {
+            delete_internal_node(right);
+        }
+    }
+
+    template <typename P>
+    bool btree<P>::try_merge_or_rebalance(iterator *iter) {
+        node_type *parent = iter->node->parent();
+        if (iter->node->position() > 0) {
+            // Try merging with our left sibling.
+            node_type *left = parent->child(iter->node->position() - 1);
+            assert(left->max_count() == kNodeValues);
+            if ((1 + left->count() + iter->node->count()) <= kNodeValues) {
+                iter->position += 1 + left->count();
+                merge_nodes(left, iter->node);
+                iter->node = left;
+                return true;
+            }
+        }
+        if (iter->node->position() < parent->count()) {
+            // Try merging with our right sibling.
+            node_type *right = parent->child(iter->node->position() + 1);
+            assert(right->max_count() == kNodeValues);
+            if ((1 + iter->node->count() + right->count()) <= kNodeValues) {
+                merge_nodes(iter->node, right);
+                return true;
+            }
+            // Try rebalancing with our right sibling. We don't perform rebalancing if
+            // we deleted the first element from iter->node and the node is not
+            // empty. This is a small optimization for the common pattern of deleting
+            // from the front of the tree.
+            if ((right->count() > kMinNodeValues) &&
+                ((iter->node->count() == 0) ||
+                 (iter->position > 0))) {
+                int to_move = (right->count() - iter->node->count()) / 2;
+                to_move = (std::min)(to_move, right->count() - 1);
+                iter->node->rebalance_right_to_left(to_move, right, mutable_allocator());
+                return false;
+            }
+        }
+        if (iter->node->position() > 0) {
+            // Try rebalancing with our left sibling. We don't perform rebalancing if
+            // we deleted the last element from iter->node and the node is not
+            // empty. This is a small optimization for the common pattern of deleting
+            // from the back of the tree.
+            node_type *left = parent->child(iter->node->position() - 1);
+            if ((left->count() > kMinNodeValues) &&
+                ((iter->node->count() == 0) ||
+                 (iter->position < iter->node->count()))) {
+                int to_move = (left->count() - iter->node->count()) / 2;
+                to_move = (std::min)(to_move, left->count() - 1);
+                left->rebalance_left_to_right(to_move, iter->node, mutable_allocator());
+                iter->position += to_move;
+                return false;
+            }
+        }
+        return false;
+    }
+
+    template <typename P>
+    void btree<P>::try_shrink() {
+        if (root()->count() > 0) {
+            return;
+        }
+        // Deleted the last item on the root node, shrink the height of the tree.
+        if (root()->leaf()) {
+            assert(size() == 0);
+            delete_leaf_node(root());
+            mutable_root() = EmptyNode();
+            rightmost_ = EmptyNode();
+        } else {
+            node_type *child = root()->child(0);
+            child->make_root();
+            delete_internal_node(root());
+            mutable_root() = child;
+        }
+    }
+
+    template <typename P>
+    template <typename IterType>
+    inline IterType btree<P>::internal_last(IterType iter) {
+        assert(iter.node != nullptr);
+        while (iter.position == iter.node->count()) {
+            iter.position = iter.node->position();
+            iter.node = iter.node->parent();
+            if (iter.node->leaf()) {
+                iter.node = nullptr;
+                break;
+            }
+        }
+        return iter;
+    }
+
+    template <typename P>
+    template <typename... Args>
+    inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
+        -> iterator {
+        if (!iter.node->leaf()) {
+            // We can't insert on an internal node. Instead, we'll insert after the
+            // previous value which is guaranteed to be on a leaf node.
+            --iter;
+            ++iter.position;
+        }
+        const int max_count = iter.node->max_count();
+        if (iter.node->count() == max_count) {
+            // Make room in the leaf for the new item.
+            if (max_count < kNodeValues) {
+                // Insertion into the root where the root is smaller than the full node
+                // size. Simply grow the size of the root node.
+                assert(iter.node == root());
+                iter.node =
+                    new_leaf_root_node((std::min<int>)(kNodeValues, 2 * max_count));
+                iter.node->swap(root(), mutable_allocator());
+                delete_leaf_node(root());
+                mutable_root() = iter.node;
+                rightmost_ = iter.node;
+            } else {
+                rebalance_or_split(&iter);
+            }
+        }
+        iter.node->emplace_value(iter.position, mutable_allocator(),
+                                 std::forward<Args>(args)...);
+        ++size_;
+        return iter;
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate(const K &key) const
+        -> SearchResult<iterator, is_key_compare_to::value> {
+        return internal_locate_impl(key, is_key_compare_to());
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate_impl(
+        const K &key, std::false_type /* IsCompareTo */) const
+        -> SearchResult<iterator, false> {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->lower_bound(key, key_comp()).value;
+            // NOTE: we don't need to walk all the way down the tree if the keys are
+            // equal, but determining equality would require doing an extra comparison
+            // on each node on the way down, and we will need to go all the way to the
+            // leaf node in the expected case.
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return {iter};
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate_impl(
+        const K &key, std::true_type /* IsCompareTo */) const
+        -> SearchResult<iterator, true> {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            SearchResult<int, true> res = iter.node->lower_bound(key, key_comp());
+            iter.position = res.value;
+            if (res.match == MatchKind::kEq) {
+                return {iter, MatchKind::kEq};
+            }
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return {iter, MatchKind::kNe};
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_lower_bound(const K &key) const -> iterator {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->lower_bound(key, key_comp()).value;
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return internal_last(iter);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->upper_bound(key, key_comp());
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return internal_last(iter);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_find(const K &key) const -> iterator {
+        auto res = internal_locate(key);
+        if (res.HasMatch()) {
+            if (res.IsEq()) {
+                return res.value;
+            }
+        } else {
+            const iterator iter = internal_last(res.value);
+            if (iter.node != nullptr && !compare_keys(key, iter.key())) {
+                return iter;
+            }
+        }
+        return {nullptr, 0};
+    }
+
+    template <typename P>
+    void btree<P>::internal_clear(node_type *node) {
+        if (!node->leaf()) {
+            for (int i = 0; i <= node->count(); ++i) {
+                internal_clear(node->child(i));
+            }
+            delete_internal_node(node);
+        } else {
+            delete_leaf_node(node);
+        }
+    }
+
+    template <typename P>
+    typename btree<P>::size_type btree<P>::internal_verify(
+        const node_type *node, const key_type *lo, const key_type *hi) const {
+        assert(node->count() > 0);
+        assert(node->count() <= node->max_count());
+        if (lo) {
+            assert(!compare_keys(node->key(0), *lo));
+        }
+        if (hi) {
+            assert(!compare_keys(*hi, node->key(node->count() - 1)));
+        }
+        for (int i = 1; i < node->count(); ++i) {
+            assert(!compare_keys(node->key(i), node->key(i - 1)));
+        }
+        size_type count = node->count();
+        if (!node->leaf()) {
+            for (int i = 0; i <= node->count(); ++i) {
+                assert(node->child(i) != nullptr);
+                assert(node->child(i)->parent() == node);
+                assert(node->child(i)->position() == i);
+                count += internal_verify(
+                    node->child(i),
+                    (i == 0) ? lo : &node->key(i - 1),
+                    (i == node->count()) ? hi : &node->key(i));
+            }
+        }
+        return count;
+    }
+
+    // A common base class for btree_set, btree_map, btree_multiset, and btree_multimap.
+    // ---------------------------------------------------------------------------------
+    template <typename Tree>
+    class btree_container {
+        using params_type = typename Tree::params_type;
+
+    protected:
+        // Alias used for heterogeneous lookup functions.
+        // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+        // `key_type` otherwise. It permits template argument deduction on `K` for the
+        // transparent case.
+        template <class K>
+        using key_arg =
+            typename KeyArg<IsTransparent<typename Tree::key_compare>::value>::
+            template type<K, typename Tree::key_type>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using difference_type = typename Tree::difference_type;
+        using key_compare = typename Tree::key_compare;
+        using value_compare = typename Tree::value_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using reference = typename Tree::reference;
+        using const_reference = typename Tree::const_reference;
+        using pointer = typename Tree::pointer;
+        using const_pointer = typename Tree::const_pointer;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using reverse_iterator = typename Tree::reverse_iterator;
+        using const_reverse_iterator = typename Tree::const_reverse_iterator;
+        using node_type = typename Tree::node_handle_type;
+
+        // Constructors/assignments.
+        btree_container() : tree_(key_compare(), allocator_type()) {}
+        explicit btree_container(const key_compare &comp,
+                                 const allocator_type &alloc = allocator_type())
+            : tree_(comp, alloc) {}
+        btree_container(const btree_container &x) = default;
+        btree_container(btree_container &&x) noexcept = default;
+        btree_container &operator=(const btree_container &x) = default;
+        btree_container &operator=(btree_container &&x) noexcept(
+            std::is_nothrow_move_assignable<Tree>::value) = default;
+
+        // Iterator routines.
+        iterator begin()                       { return tree_.begin(); }
+        const_iterator begin() const           { return tree_.begin(); }
+        const_iterator cbegin() const          { return tree_.begin(); }
+        iterator end()                         { return tree_.end(); }
+        const_iterator end() const             { return tree_.end(); }
+        const_iterator cend() const            { return tree_.end(); }
+        reverse_iterator rbegin()              { return tree_.rbegin(); }
+        const_reverse_iterator rbegin() const  { return tree_.rbegin(); }
+        const_reverse_iterator crbegin() const { return tree_.rbegin(); }
+        reverse_iterator rend()                { return tree_.rend(); }
+        const_reverse_iterator rend() const    { return tree_.rend(); }
+        const_reverse_iterator crend() const   { return tree_.rend(); }
+
+        // Lookup routines.
+        // ----------------
+        template <typename K = key_type>
+        size_type count(const key_arg<K> &key) const {
+            auto equal_range = this->equal_range(key);
+            return std::distance(equal_range.first, equal_range.second);
+        }
+        template <typename K = key_type>
+        iterator find(const key_arg<K> &key) {
+            return tree_.find(key);
+        }
+        template <typename K = key_type>
+        const_iterator find(const key_arg<K> &key) const { return tree_.find(key); }
+
+        template <typename K = key_type>
+        bool contains(const key_arg<K> &key) const { return find(key) != end(); }
+
+        template <typename K = key_type>
+        iterator lower_bound(const key_arg<K> &key) { return tree_.lower_bound(key); }
+
+        template <typename K = key_type>
+        const_iterator lower_bound(const key_arg<K> &key) const { return tree_.lower_bound(key); }
+
+        template <typename K = key_type>
+        iterator upper_bound(const key_arg<K> &key) { return tree_.upper_bound(key); }
+
+        template <typename K = key_type>
+        const_iterator upper_bound(const key_arg<K> &key) const { return tree_.upper_bound(key); }
+
+        template <typename K = key_type>
+        std::pair<iterator, iterator> equal_range(const key_arg<K> &key) { return tree_.equal_range(key); }
+
+        template <typename K = key_type>
+        std::pair<const_iterator, const_iterator> equal_range(
+            const key_arg<K> &key) const {
+            return tree_.equal_range(key);
+        }
+
+        iterator erase(const_iterator iter) { return tree_.erase(iterator(iter)); }
+        iterator erase(iterator iter)       { return tree_.erase(iter); }
+        iterator erase(const_iterator first, const_iterator last) {
+            return tree_.erase(iterator(first), iterator(last)).second;
+        }
+        template <typename K = key_type>
+        size_type erase(const key_arg<K> &key) {
+            auto equal_range = this->equal_range(key);
+            return tree_.erase_range(equal_range.first, equal_range.second).first;
+        }
+        node_type extract(iterator position) {
+            // Use Move instead of Transfer, because the rebalancing code expects to
+            // have a valid object to scribble metadata bits on top of.
+            auto node = CommonAccess::Move<node_type>(get_allocator(), position.slot());
+            erase(position);
+            return node;
+        }
+
+        node_type extract(const_iterator position) {
+            return extract(iterator(position));
+        }
+
+    public:
+        void clear() { tree_.clear(); }
+        void swap(btree_container &x) { tree_.swap(x.tree_); }
+        void verify() const { tree_.verify(); }
+
+        size_type size() const { return tree_.size(); }
+        size_type max_size() const { return tree_.max_size(); }
+        bool empty() const { return tree_.empty(); }
+
+        friend bool operator==(const btree_container &x, const btree_container &y) {
+            if (x.size() != y.size()) return false;
+            return std::equal(x.begin(), x.end(), y.begin());
+        }
+
+        friend bool operator!=(const btree_container &x, const btree_container &y) { return !(x == y); }
+
+        friend bool operator<(const btree_container &x, const btree_container &y) {
+            return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
+        }
+
+        friend bool operator>(const btree_container &x, const btree_container &y) { return y < x; }
+
+        friend bool operator<=(const btree_container &x, const btree_container &y) { return !(y < x); }
+
+        friend bool operator>=(const btree_container &x, const btree_container &y) { return !(x < y); }
+
+        // The allocator used by the btree.
+        allocator_type get_allocator() const { return tree_.get_allocator(); }
+
+        // The key comparator used by the btree.
+        key_compare key_comp() const { return tree_.key_comp(); }
+        value_compare value_comp() const { return tree_.value_comp(); }
+
+        // Support absl::Hash.
+        template <typename State>
+        friend State AbslHashValue(State h, const btree_container &b) {
+            for (const auto &v : b) {
+                h = State::combine(std::move(h), v);
+            }
+            return State::combine(std::move(h), b.size());
+        }
+
+    protected:
+        Tree tree_;
+    };
+
+    // A common base class for btree_set and btree_map.
+    // -----------------------------------------------
+    template <typename Tree>
+    class btree_set_container : public btree_container<Tree> {
+        using super_type = btree_container<Tree>;
+        using params_type = typename Tree::params_type;
+        using init_type = typename params_type::init_type;
+        using is_key_compare_to = typename params_type::is_key_compare_to;
+        friend class BtreeNodePeer;
+
+    protected:
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using node_type = typename super_type::node_type;
+        using insert_return_type = InsertReturnType<iterator, node_type>;
+        using super_type::super_type;
+        btree_set_container() {}
+
+        template <class InputIterator>
+        btree_set_container(InputIterator b, InputIterator e,
+                            const key_compare &comp = key_compare(),
+                            const allocator_type &alloc = allocator_type())
+            : super_type(comp, alloc) {
+            insert(b, e);
+        }
+
+        btree_set_container(std::initializer_list<init_type> init,
+                            const key_compare &comp = key_compare(),
+                            const allocator_type &alloc = allocator_type())
+            : btree_set_container(init.begin(), init.end(), comp, alloc) {}
+
+        btree_set_container(std::initializer_list<init_type> init,
+                            const allocator_type &alloc)
+            : btree_set_container(init.begin(), init.end(), alloc) {}
+
+        // Lookup routines.
+        template <typename K = key_type>
+        size_type count(const key_arg<K> &key) const {
+            return this->tree_.count_unique(key);
+        }
+
+        // Insertion routines.
+        std::pair<iterator, bool> insert(const value_type &x) {
+            return this->tree_.insert_unique(params_type::key(x), x);
+        }
+        std::pair<iterator, bool> insert(value_type &&x) {
+            return this->tree_.insert_unique(params_type::key(x), std::move(x));
+        }
+        template <typename... Args>
+        std::pair<iterator, bool> emplace(Args &&... args) {
+            init_type v(std::forward<Args>(args)...);
+            return this->tree_.insert_unique(params_type::key(v), std::move(v));
+        }
+        iterator insert(const_iterator hint, const value_type &x) {
+            return this->tree_
+                .insert_hint_unique(iterator(hint), params_type::key(x), x)
+                .first;
+        }
+        iterator insert(const_iterator hint, value_type &&x) {
+            return this->tree_
+                .insert_hint_unique(iterator(hint), params_type::key(x),
+                                    std::move(x))
+                .first;
+        }
+
+        template <typename... Args>
+        iterator emplace_hint(const_iterator hint, Args &&... args) {
+            init_type v(std::forward<Args>(args)...);
+            return this->tree_
+                .insert_hint_unique(iterator(hint), params_type::key(v),
+                                    std::move(v))
+                .first;
+        }
+
+        template <typename InputIterator>
+        void insert(InputIterator b, InputIterator e) {
+            this->tree_.insert_iterator_unique(b, e);
+        }
+
+        void insert(std::initializer_list<init_type> init) {
+            this->tree_.insert_iterator_unique(init.begin(), init.end());
+        }
+
+        insert_return_type insert(node_type &&node) {
+            if (!node) return {this->end(), false, node_type()};
+            std::pair<iterator, bool> res =
+                this->tree_.insert_unique(params_type::key(CommonAccess::GetSlot(node)),
+                                          CommonAccess::GetSlot(node));
+            if (res.second) {
+                CommonAccess::Destroy(&node);
+                return {res.first, true, node_type()};
+            } else {
+                return {res.first, false, std::move(node)};
+            }
+        }
+
+        iterator insert(const_iterator hint, node_type &&node) {
+            if (!node) return this->end();
+            std::pair<iterator, bool> res = this->tree_.insert_hint_unique(
+                iterator(hint), params_type::key(CommonAccess::GetSlot(node)),
+                CommonAccess::GetSlot(node));
+            if (res.second) CommonAccess::Destroy(&node);
+            return res.first;
+        }
+
+        template <typename K = key_type>
+        size_type erase(const key_arg<K> &key) { return this->tree_.erase_unique(key); }
+        using super_type::erase;
+
+        template <typename K = key_type>
+        node_type extract(const key_arg<K> &key) {
+            auto it = this->find(key);
+            return it == this->end() ? node_type() : extract(it);
+        }
+
+        using super_type::extract;
+
+        // Merge routines.
+        // Moves elements from `src` into `this`. If the element already exists in
+        // `this`, it is left unmodified in `src`.
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &src) {  // NOLINT
+            for (auto src_it = src.begin(); src_it != src.end();) {
+                if (insert(std::move(*src_it)).second) {
+                    src_it = src.erase(src_it);
+                } else {
+                    ++src_it;
+                }
+            }
+        }
+
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &&src) {
+            merge(src);
+        }
+    };
+
+    // Base class for btree_map.
+    // -------------------------
+    template <typename Tree>
+    class btree_map_container : public btree_set_container<Tree> {
+        using super_type = btree_set_container<Tree>;
+        using params_type = typename Tree::params_type;
+
+    protected:
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using mapped_type = typename params_type::mapped_type;
+        using value_type = typename Tree::value_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_map_container() {}
+
+        // Insertion routines.
+        template <typename... Args>
+        std::pair<iterator, bool> try_emplace(const key_type &k, Args &&... args) {
+            return this->tree_.insert_unique(
+                k, std::piecewise_construct, std::forward_as_tuple(k),
+                std::forward_as_tuple(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        std::pair<iterator, bool> try_emplace(key_type &&k, Args &&... args) {
+            // Note: `key_ref` exists to avoid a ClangTidy warning about moving from `k`
+            // and then using `k` unsequenced. This is safe because the move is into a
+            // forwarding reference and insert_unique guarantees that `key` is never
+            // referenced after consuming `args`.
+            const key_type& key_ref = k;
+            return this->tree_.insert_unique(
+                key_ref, std::piecewise_construct, std::forward_as_tuple(std::move(k)),
+                std::forward_as_tuple(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        iterator try_emplace(const_iterator hint, const key_type &k,
+                             Args &&... args) {
+            return this->tree_
+                .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
+                                    std::forward_as_tuple(k),
+                                    std::forward_as_tuple(std::forward<Args>(args)...))
+                .first;
+        }
+        template <typename... Args>
+        iterator try_emplace(const_iterator hint, key_type &&k, Args &&... args) {
+            // Note: `key_ref` exists to avoid a ClangTidy warning about moving from `k`
+            // and then using `k` unsequenced. This is safe because the move is into a
+            // forwarding reference and insert_hint_unique guarantees that `key` is
+            // never referenced after consuming `args`.
+            const key_type& key_ref = k;
+            return this->tree_
+                .insert_hint_unique(iterator(hint), key_ref, std::piecewise_construct,
+                                    std::forward_as_tuple(std::move(k)),
+                                    std::forward_as_tuple(std::forward<Args>(args)...))
+                .first;
+        }
+        mapped_type &operator[](const key_type &k) {
+            return try_emplace(k).first->second;
+        }
+        mapped_type &operator[](key_type &&k) {
+            return try_emplace(std::move(k)).first->second;
+        }
+
+        template <typename K = key_type>
+        mapped_type &at(const key_arg<K> &key) {
+            auto it = this->find(key);
+            if (it == this->end())
+                base_internal::ThrowStdOutOfRange("phmap::btree_map::at");
+            return it->second;
+        }
+        template <typename K = key_type>
+        const mapped_type &at(const key_arg<K> &key) const {
+            auto it = this->find(key);
+            if (it == this->end())
+                base_internal::ThrowStdOutOfRange("phmap::btree_map::at");
+            return it->second;
+        }
+    };
+
+    // A common base class for btree_multiset and btree_multimap.
+    template <typename Tree>
+    class btree_multiset_container : public btree_container<Tree> {
+        using super_type = btree_container<Tree>;
+        using params_type = typename Tree::params_type;
+        using init_type = typename params_type::init_type;
+        using is_key_compare_to = typename params_type::is_key_compare_to;
+
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using node_type = typename super_type::node_type;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_multiset_container() {}
+
+        // Range constructor.
+        template <class InputIterator>
+        btree_multiset_container(InputIterator b, InputIterator e,
+                                 const key_compare &comp = key_compare(),
+                                 const allocator_type &alloc = allocator_type())
+            : super_type(comp, alloc) {
+            insert(b, e);
+        }
+
+        // Initializer list constructor.
+        btree_multiset_container(std::initializer_list<init_type> init,
+                                 const key_compare &comp = key_compare(),
+                                 const allocator_type &alloc = allocator_type())
+            : btree_multiset_container(init.begin(), init.end(), comp, alloc) {}
+
+        // Lookup routines.
+        template <typename K = key_type>
+        size_type count(const key_arg<K> &key) const {
+            return this->tree_.count_multi(key);
+        }
+
+        // Insertion routines.
+        iterator insert(const value_type &x) { return this->tree_.insert_multi(x); }
+        iterator insert(value_type &&x) {
+            return this->tree_.insert_multi(std::move(x));
+        }
+        iterator insert(const_iterator hint, const value_type &x) {
+            return this->tree_.insert_hint_multi(iterator(hint), x);
+        }
+        iterator insert(const_iterator hint, value_type &&x) {
+            return this->tree_.insert_hint_multi(iterator(hint), std::move(x));
+        }
+        template <typename InputIterator>
+        void insert(InputIterator b, InputIterator e) {
+            this->tree_.insert_iterator_multi(b, e);
+        }
+        void insert(std::initializer_list<init_type> init) {
+            this->tree_.insert_iterator_multi(init.begin(), init.end());
+        }
+        template <typename... Args>
+        iterator emplace(Args &&... args) {
+            return this->tree_.insert_multi(init_type(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        iterator emplace_hint(const_iterator hint, Args &&... args) {
+            return this->tree_.insert_hint_multi(
+                iterator(hint), init_type(std::forward<Args>(args)...));
+        }
+        iterator insert(node_type &&node) {
+            if (!node) return this->end();
+            iterator res =
+                this->tree_.insert_multi(params_type::key(CommonAccess::GetSlot(node)),
+                                         CommonAccess::GetSlot(node));
+            CommonAccess::Destroy(&node);
+            return res;
+        }
+        iterator insert(const_iterator hint, node_type &&node) {
+            if (!node) return this->end();
+            iterator res = this->tree_.insert_hint_multi(
+                iterator(hint),
+                std::move(params_type::element(CommonAccess::GetSlot(node))));
+            CommonAccess::Destroy(&node);
+            return res;
+        }
+
+        // Deletion routines.
+        template <typename K = key_type>
+        size_type erase(const key_arg<K> &key) {
+            return this->tree_.erase_multi(key);
+        }
+        using super_type::erase;
+
+        // Node extraction routines.
+        template <typename K = key_type>
+        node_type extract(const key_arg<K> &key) {
+            auto it = this->find(key);
+            return it == this->end() ? node_type() : extract(it);
+        }
+        using super_type::extract;
+
+        // Merge routines.
+        // Moves all elements from `src` into `this`.
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+        void merge(btree_container<T> &src) {  // NOLINT
+            insert(std::make_move_iterator(src.begin()),
+                   std::make_move_iterator(src.end()));
+            src.clear();
+        }
+
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+        void merge(btree_container<T> &&src) {
+            merge(src);
+        }
+    };
+
+    // A base class for btree_multimap.
+    template <typename Tree>
+    class btree_multimap_container : public btree_multiset_container<Tree> {
+        using super_type = btree_multiset_container<Tree>;
+        using params_type = typename Tree::params_type;
+
+    public:
+        using mapped_type = typename params_type::mapped_type;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_multimap_container() {}
+    };
+
+}  // namespace priv
+
+
+
+    // ----------------------------------------------------------------------
+    //  btree_set - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Compare, typename Alloc>
+    class btree_set : public priv::btree_set_container<
+        priv::btree<priv::set_params<
+            Key, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ false>>> 
+    {
+        using Base = typename btree_set::btree_set_container;
+
+    public:
+        btree_set() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::lower_bound;
+        using Base::upper_bound;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_set` containers.
+    // -------------------------------------------------------
+    template <typename K, typename C, typename A>
+    void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename C, typename A, typename Pred>
+    void erase_if(btree_set<K, C, A> &set, Pred pred) {
+        for (auto it = set.begin(); it != set.end();) {
+            if (pred(*it)) {
+                it = set.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    //  btree_multiset - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Compare,  typename Alloc>
+        class btree_multiset : public priv::btree_multiset_container<
+        priv::btree<priv::set_params<
+             Key, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ true>>> 
+    {
+        using Base = typename btree_multiset::btree_multiset_container;
+        
+    public:
+        btree_multiset() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::lower_bound;
+        using Base::upper_bound;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_multiset` containers.
+    // ------------------------------------------------------------
+    template <typename K, typename C, typename A>
+    void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
+        return x.swap(y);
+    }
+    
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename C, typename A, typename Pred>
+    void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
+        for (auto it = set.begin(); it != set.end();) {
+            if (pred(*it)) {
+                it = set.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+
+    // ----------------------------------------------------------------------
+    //  btree_map - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Value, typename Compare,  typename Alloc>
+        class btree_map : public priv::btree_map_container<
+        priv::btree<priv::map_params<
+             Key, Value, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ false>>> 
+    {
+        using Base = typename btree_map::btree_map_container;
+
+    public:
+        btree_map() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::try_emplace;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::at;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::lower_bound;
+        using Base::upper_bound;
+        using Base::find;
+        using Base::operator[];
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_map` containers.
+    // -------------------------------------------------------
+    template <typename K, typename V, typename C, typename A>
+    void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // ----------------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A, typename Pred>
+    void erase_if(btree_map<K, V, C, A> &map, Pred pred) {
+        for (auto it = map.begin(); it != map.end();) {
+            if (pred(*it)) {
+                it = map.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    //  btree_multimap - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Value, typename Compare, typename Alloc>
+        class btree_multimap : public priv::btree_multimap_container<
+        priv::btree<priv::map_params<
+              Key, Value, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ true>>> 
+    {
+        using Base = typename btree_multimap::btree_multimap_container;
+
+    public:
+        btree_multimap() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::lower_bound;
+        using Base::upper_bound;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_multimap` containers.
+    // ------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A>
+    void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A, typename Pred>
+    void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
+        for (auto it = map.begin(); it != map.end();) {
+            if (pred(*it)) {
+                it = map.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+
+}  // namespace btree
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif  // PHMAP_BTREE_BTREE_CONTAINER_H_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/conanfile.py b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/conanfile.py
new file mode 100644
index 00000000..42112473
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/conanfile.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from conans import ConanFile, tools
+import os
+
+class SparseppConan(ConanFile):
+    name = "parallel_hashmap"
+    version = "1.36"
+    description = "A header-only, very fast and memory-friendly hash map"
+    url = "https://github.com/greg7mdp/parallel-hashmap/blob/master/parallel_hashmap/conanfile.py"
+    
+    # Indicates License type of the packaged library
+    license = "https://github.com/greg7mdp/parallel-hashmap/blob/master/LICENSE"
+    
+    # Packages the license for the conanfile.py
+    exports = ["LICENSE"]
+    
+    # Custom attributes for Bincrafters recipe conventions
+    source_subfolder = "source_subfolder"
+    
+    def source(self):
+        source_url = "https://github.com/greg7mdp/parallel-hashmap"
+        tools.get("{0}/archive/{1}.tar.gz".format(source_url, self.version))
+        extracted_dir = self.name + "-" + self.version
+
+        #Rename to "source_folder" is a convention to simplify later steps
+        os.rename(extracted_dir, self.source_subfolder)
+
+
+    def package(self):
+        include_folder = os.path.join(self.source_subfolder, "parallel_hashmap")
+        self.copy(pattern="LICENSE")
+        self.copy(pattern="*", dst="include/parallel_hashmap", src=include_folder)
+
+    def package_id(self):
+        self.info.header_only()
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/meminfo.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/meminfo.h
new file mode 100644
index 00000000..872f3c69
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/meminfo.h
@@ -0,0 +1,195 @@
+#if !defined(spp_memory_h_guard)
+#define spp_memory_h_guard
+
+#include <cstdint>
+#include <cstring>
+#include <cstdlib>
+
+#if defined(_WIN32) || defined( __CYGWIN__)
+    #define SPP_WIN
+#endif
+
+#ifdef SPP_WIN
+    #include <windows.h>
+    #include <Psapi.h>
+    #undef min
+    #undef max
+#elif defined(__linux__)
+    #include <sys/types.h>
+    #include <sys/sysinfo.h>
+#elif defined(__FreeBSD__)
+    #include <paths.h>
+    #include <fcntl.h>
+    #include <kvm.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+    #include <sys/user.h>
+#endif
+
+namespace spp
+{
+    uint64_t GetSystemMemory();
+    uint64_t GetTotalMemoryUsed();
+    uint64_t GetProcessMemoryUsed();
+    uint64_t GetPhysicalMemory();
+
+    uint64_t GetSystemMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo (&memInfo);
+        auto totalVirtualMem = memInfo.totalram;
+
+        totalVirtualMem += memInfo.totalswap;
+        totalVirtualMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalVirtualMem);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        u_int pageSize;
+        struct kvm_swap kswap;
+        uint64_t totalVirtualMem;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        totalVirtualMem = pageCnt * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        totalVirtualMem += kswap.ksw_total * pageSize;
+
+        return totalVirtualMem;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetTotalMemoryUsed()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile - memInfo.ullAvailPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+        auto virtualMemUsed = memInfo.totalram - memInfo.freeram;
+
+        virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
+        virtualMemUsed *= memInfo.mem_unit;
+
+        return static_cast<uint64_t>(virtualMemUsed);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageSize;
+        u_int pageCnt, freeCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        size_t freeCntLen = sizeof(freeCnt);
+        struct kvm_swap kswap;
+        uint64_t virtualMemUsed;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        sysctlbyname("vm.stats.vm.v_free_count", &freeCnt, &freeCntLen, NULL, 0);
+        virtualMemUsed = (pageCnt - freeCnt) * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        virtualMemUsed += kswap.ksw_used * pageSize;
+
+        return virtualMemUsed;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetProcessMemoryUsed()
+    {
+#ifdef SPP_WIN
+        PROCESS_MEMORY_COUNTERS_EX pmc;
+        GetProcessMemoryInfo(GetCurrentProcess(), reinterpret_cast<PPROCESS_MEMORY_COUNTERS>(&pmc), sizeof(pmc));
+        return static_cast<uint64_t>(pmc.PrivateUsage);
+#elif defined(__linux__)
+        auto parseLine = 
+            [](char* line)->int
+            {
+                auto i = strlen(line);
+				
+                while(*line < '0' || *line > '9') 
+                {
+                    line++;
+                }
+
+                line[i-3] = '\0';
+                i = atoi(line);
+                return i;
+            };
+
+        auto file = fopen("/proc/self/status", "r");
+        auto result = -1;
+        char line[128];
+
+        while(fgets(line, 128, file) != nullptr)
+        {
+            if(strncmp(line, "VmSize:", 7) == 0)
+            {
+                result = parseLine(line);
+                break;
+            }
+        }
+
+        fclose(file);
+        return static_cast<uint64_t>(result) * 1024;
+#elif defined(__FreeBSD__)
+        struct kinfo_proc info;
+        size_t infoLen = sizeof(info);
+        int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &infoLen, NULL, 0);
+        return static_cast<uint64_t>(info.ki_rssize * getpagesize());
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetPhysicalMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPhys);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+
+        auto totalPhysMem = memInfo.totalram;
+
+        totalPhysMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalPhysMem);
+#elif defined(__FreeBSD__)
+        u_long physMem;
+        size_t physMemLen = sizeof(physMem);
+        int mib[] = { CTL_HW, HW_PHYSMEM };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &physMem, &physMemLen, NULL, 0);
+        return physMem;
+#else
+        return 0;
+#endif
+    }
+
+}
+
+#endif // spp_memory_h_guard
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap.h
new file mode 100644
index 00000000..a4215875
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap.h
@@ -0,0 +1,5118 @@
+#if !defined(phmap_h_guard_)
+#define phmap_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// IMPLEMENTATION DETAILS
+//
+// The table stores elements inline in a slot array. In addition to the slot
+// array the table maintains some control state per slot. The extra state is one
+// byte per slot and stores empty or deleted marks, or alternatively 7 bits from
+// the hash of an occupied slot. The table is split into logical groups of
+// slots, like so:
+//
+//      Group 1         Group 2        Group 3
+// +---------------+---------------+---------------+
+// | | | | | | | | | | | | | | | | | | | | | | | | |
+// +---------------+---------------+---------------+
+//
+// On lookup the hash is split into two parts:
+// - H2: 7 bits (those stored in the control bytes)
+// - H1: the rest of the bits
+// The groups are probed using H1. For each group the slots are matched to H2 in
+// parallel. Because H2 is 7 bits (128 states) and the number of slots per group
+// is low (8 or 16) in almost all cases a match in H2 is also a lookup hit.
+//
+// On insert, once the right group is found (as in lookup), its slots are
+// filled in order.
+//
+// On erase a slot is cleared. In case the group did not have any empty slots
+// before the erase, the erased slot is marked as deleted.
+//
+// Groups without empty slots (but maybe with deleted slots) extend the probe
+// sequence. The probing algorithm is quadratic. Given N the number of groups,
+// the probing function for the i'th probe is:
+//
+//   P(0) = H1 % N
+//
+//   P(i) = (P(i - 1) + i) % N
+//
+// This probing function guarantees that after N probes, all the groups of the
+// table will be probed exactly once.
+//
+// The control state and slot array are stored contiguously in a shared heap
+// allocation. The layout of this allocation is: `capacity()` control bytes,
+// one sentinel control byte, `Group::kWidth - 1` cloned control bytes,
+// <possible padding>, `capacity()` slots. The sentinel control byte is used in
+// iteration so we know when we reach the end of the table. The cloned control
+// bytes at the end of the table are cloned from the beginning of the table so
+// groups that begin near the end of the table can see a full group. In cases in
+// which there are more than `capacity()` cloned control bytes, the extra bytes
+// are `kEmpty`, and these ensure that we always see at least one empty slot and
+// can stop an unsuccessful search.
+// ---------------------------------------------------------------------------
+
+
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+
+    #pragma warning(disable : 4127) // conditional expression is constant
+    #pragma warning(disable : 4324) // structure was padded due to alignment specifier
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4623) // default constructor was implicitly defined as deleted
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+    #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order in braced initializer list
+    #pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
+#endif
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <array>
+#include <cassert>
+#include <atomic>
+
+#include "phmap_fwd_decl.h"
+#include "phmap_utils.h"
+#include "phmap_base.h"
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    #include <string_view>
+#endif
+
+namespace phmap {
+
+namespace priv {
+
+// --------------------------------------------------------------------------
+template <typename AllocType>
+void SwapAlloc(AllocType& lhs, AllocType& rhs,
+               std::true_type /* propagate_on_container_swap */) {
+  using std::swap;
+  swap(lhs, rhs);
+}
+template <typename AllocType>
+void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/,
+               std::false_type /* propagate_on_container_swap */) {}
+
+// --------------------------------------------------------------------------
+template <size_t Width>
+class probe_seq 
+{
+public:
+    probe_seq(size_t hashval, size_t mask) {
+        assert(((mask + 1) & mask) == 0 && "not a mask");
+        mask_ = mask;
+        offset_ = hashval & mask_;
+    }
+    size_t offset() const { return offset_; }
+    size_t offset(size_t i) const { return (offset_ + i) & mask_; }
+
+    void next() {
+        index_ += Width;
+        offset_ += index_;
+        offset_ &= mask_;
+    }
+    // 0-based probe index. The i-th probe in the probe sequence.
+    size_t getindex() const { return index_; }
+
+private:
+    size_t mask_;
+    size_t offset_;
+    size_t index_ = 0;
+};
+
+// --------------------------------------------------------------------------
+template <class ContainerKey, class Hash, class Eq>
+struct RequireUsableKey 
+{
+    template <class PassedKey, class... Args>
+    std::pair<
+        decltype(std::declval<const Hash&>()(std::declval<const PassedKey&>())),
+        decltype(std::declval<const Eq&>()(std::declval<const ContainerKey&>(),
+                                           std::declval<const PassedKey&>()))>*
+    operator()(const PassedKey&, const Args&...) const;
+};
+
+// --------------------------------------------------------------------------
+template <class E, class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable : std::false_type {};
+
+template <class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable<
+    phmap::void_t<decltype(
+        Policy::apply(RequireUsableKey<typename Policy::key_type, Hash, Eq>(),
+                      std::declval<Ts>()...))>,
+    Policy, Hash, Eq, Ts...> : std::true_type {};
+
+// TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
+// --------------------------------------------------------------------------
+template <class T>
+constexpr bool IsNoThrowSwappable() {
+    using std::swap;
+    return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+}
+
+// --------------------------------------------------------------------------
+template <typename T>
+int TrailingZeros(T x) {
+    PHMAP_IF_CONSTEXPR(sizeof(T) == 8)
+        return base_internal::CountTrailingZerosNonZero64(static_cast<uint64_t>(x));
+    else
+        return base_internal::CountTrailingZerosNonZero32(static_cast<uint32_t>(x));
+}
+
+// --------------------------------------------------------------------------
+template <typename T>
+int LeadingZeros(T x) {
+    PHMAP_IF_CONSTEXPR(sizeof(T) == 8)
+        return base_internal::CountLeadingZeros64(static_cast<uint64_t>(x));
+    else
+        return base_internal::CountLeadingZeros32(static_cast<uint32_t>(x));
+}
+
+// --------------------------------------------------------------------------
+// An abstraction over a bitmask. It provides an easy way to iterate through the
+// indexes of the set bits of a bitmask.  When Shift=0 (platforms with SSE),
+// this is a true bitmask.  On non-SSE, platforms the arithematic used to
+// emulate the SSE behavior works in bytes (Shift=3) and leaves each bytes as
+// either 0x00 or 0x80.
+//
+// For example:
+//   for (int i : BitMask<uint32_t, 16>(0x5)) -> yields 0, 2
+//   for (int i : BitMask<uint64_t, 8, 3>(0x0000000080800000)) -> yields 2, 3
+// --------------------------------------------------------------------------
+template <class T, int SignificantBits, int Shift = 0>
+class BitMask 
+{
+    static_assert(std::is_unsigned<T>::value, "");
+    static_assert(Shift == 0 || Shift == 3, "");
+
+public:
+    // These are useful for unit tests (gunit).
+    using value_type = int;
+    using iterator = BitMask;
+    using const_iterator = BitMask;
+
+    explicit BitMask(T mask) : mask_(mask) {}
+
+    BitMask& operator++() {    // ++iterator
+        mask_ &= (mask_ - 1);  // clear the least significant bit set
+        return *this;
+    }
+
+    explicit operator bool() const { return mask_ != 0; }
+    uint32_t operator*() const { return LowestBitSet(); }
+
+    uint32_t LowestBitSet() const {
+        return priv::TrailingZeros(mask_) >> Shift;
+    }
+
+    uint32_t HighestBitSet() const {
+        return (sizeof(T) * CHAR_BIT - priv::LeadingZeros(mask_) - 1) >> Shift;
+    }
+
+    BitMask begin() const { return *this; }
+    BitMask end() const { return BitMask(0); }
+
+    uint32_t TrailingZeros() const {
+        return priv::TrailingZeros(mask_) >> Shift;
+    }
+
+    uint32_t LeadingZeros() const {
+        constexpr uint32_t total_significant_bits = SignificantBits << Shift;
+        constexpr uint32_t extra_bits = sizeof(T) * 8 - total_significant_bits;
+        return priv::LeadingZeros(mask_ << extra_bits) >> Shift;
+    }
+
+private:
+    friend bool operator==(const BitMask& a, const BitMask& b) {
+        return a.mask_ == b.mask_;
+    }
+    friend bool operator!=(const BitMask& a, const BitMask& b) {
+        return a.mask_ != b.mask_;
+    }
+
+    T mask_;
+};
+
+// --------------------------------------------------------------------------
+using ctrl_t = signed char;
+using h2_t = uint8_t;
+
+// --------------------------------------------------------------------------
+// The values here are selected for maximum performance. See the static asserts
+// below for details.
+// --------------------------------------------------------------------------
+enum Ctrl : ctrl_t 
+{
+    kEmpty = -128,   // 0b10000000 or 0x80
+    kDeleted = -2,   // 0b11111110 or 0xfe
+    kSentinel = -1,  // 0b11111111 or 0xff
+};
+
+static_assert(
+    kEmpty & kDeleted & kSentinel & 0x80,
+    "Special markers need to have the MSB to make checking for them efficient");
+static_assert(kEmpty < kSentinel && kDeleted < kSentinel,
+              "kEmpty and kDeleted must be smaller than kSentinel to make the "
+              "SIMD test of IsEmptyOrDeleted() efficient");
+static_assert(kSentinel == -1,
+              "kSentinel must be -1 to elide loading it from memory into SIMD "
+              "registers (pcmpeqd xmm, xmm)");
+static_assert(kEmpty == -128,
+              "kEmpty must be -128 to make the SIMD check for its "
+              "existence efficient (psignb xmm, xmm)");
+static_assert(~kEmpty & ~kDeleted & kSentinel & 0x7F,
+              "kEmpty and kDeleted must share an unset bit that is not shared "
+              "by kSentinel to make the scalar test for MatchEmptyOrDeleted() "
+              "efficient");
+static_assert(kDeleted == -2,
+              "kDeleted must be -2 to make the implementation of "
+              "ConvertSpecialToEmptyAndFullToDeleted efficient");
+
+// --------------------------------------------------------------------------
+// A single block of empty control bytes for tables without any slots allocated.
+// This enables removing a branch in the hot path of find().
+// --------------------------------------------------------------------------
+inline ctrl_t* EmptyGroup() {
+  alignas(16) static constexpr ctrl_t empty_group[] = {
+      kSentinel, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty,
+      kEmpty,    kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty};
+  return const_cast<ctrl_t*>(empty_group);
+}
+
+// --------------------------------------------------------------------------
+inline size_t HashSeed(const ctrl_t* ctrl) {
+  // The low bits of the pointer have little or no entropy because of
+  // alignment. We shift the pointer to try to use higher entropy bits. A
+  // good number seems to be 12 bits, because that aligns with page size.
+  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
+}
+
+#ifdef PHMAP_NON_DETERMINISTIC
+
+inline size_t H1(size_t hashval, const ctrl_t* ctrl) {
+    // use ctrl_ pointer to add entropy to ensure
+    // non-deterministic iteration order.
+    return (hashval >> 7) ^ HashSeed(ctrl);
+}
+
+#else
+
+inline size_t H1(size_t hashval, const ctrl_t* ) {
+    return (hashval >> 7);
+}
+
+#endif
+
+
+inline h2_t H2(size_t hashval)       { return (ctrl_t)(hashval & 0x7F); }
+
+inline bool IsEmpty(ctrl_t c)          { return c == kEmpty; }
+inline bool IsFull(ctrl_t c)           { return c >= static_cast<ctrl_t>(0); }
+inline bool IsDeleted(ctrl_t c)        { return c == kDeleted; }
+inline bool IsEmptyOrDeleted(ctrl_t c) { return c < kSentinel; }
+
+#if PHMAP_HAVE_SSE2
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4365) // conversion from 'int' to 'T', signed/unsigned mismatch
+#endif
+
+// --------------------------------------------------------------------------
+// https://github.com/abseil/abseil-cpp/issues/209
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
+// _mm_cmpgt_epi8 is broken under GCC with -funsigned-char
+// Work around this by using the portable implementation of Group
+// when using -funsigned-char under GCC.
+// --------------------------------------------------------------------------
+inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
+#if defined(__GNUC__) && !defined(__clang__)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Woverflow"
+
+  if (std::is_unsigned<char>::value) {
+    const __m128i mask = _mm_set1_epi8(static_cast<char>(0x80));
+    const __m128i diff = _mm_subs_epi8(b, a);
+    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
+  }
+
+  #pragma GCC diagnostic pop
+#endif
+  return _mm_cmpgt_epi8(a, b);
+}
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+struct GroupSse2Impl 
+{
+    enum { kWidth = 16 };  // the number of slots per group
+
+    explicit GroupSse2Impl(const ctrl_t* pos) {
+        ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
+    }
+
+    // Returns a bitmask representing the positions of slots that match hash.
+    // ----------------------------------------------------------------------
+    BitMask<uint32_t, kWidth> Match(h2_t hash) const {
+        auto match = _mm_set1_epi8((char)hash);
+        return BitMask<uint32_t, kWidth>(
+            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+    }
+
+    // Returns a bitmask representing the positions of empty slots.
+    // ------------------------------------------------------------
+    BitMask<uint32_t, kWidth> MatchEmpty() const {
+#if PHMAP_HAVE_SSSE3
+        // This only works because kEmpty is -128.
+        return BitMask<uint32_t, kWidth>(
+            static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
+#else
+        return Match(static_cast<h2_t>(kEmpty));
+#endif
+    }
+
+#ifdef __INTEL_COMPILER
+#pragma warning push
+#pragma warning disable 68
+#endif
+    // Returns a bitmask representing the positions of empty or deleted slots.
+    // -----------------------------------------------------------------------
+    BitMask<uint32_t, kWidth> MatchEmptyOrDeleted() const {
+        auto special = _mm_set1_epi8(static_cast<uint8_t>(kSentinel));
+        return BitMask<uint32_t, kWidth>(
+            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
+    }
+
+    // Returns the number of trailing empty or deleted elements in the group.
+    // ----------------------------------------------------------------------
+    uint32_t CountLeadingEmptyOrDeleted() const {
+        auto special = _mm_set1_epi8(static_cast<uint8_t>(kSentinel));
+        return TrailingZeros(
+            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
+    }
+#ifdef __INTEL_COMPILER
+#pragma warning pop
+#endif
+
+    // ----------------------------------------------------------------------
+    void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+        auto msbs = _mm_set1_epi8(static_cast<char>(-128));
+        auto x126 = _mm_set1_epi8(126);
+#if PHMAP_HAVE_SSSE3
+        auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
+#else
+        auto zero = _mm_setzero_si128();
+        auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
+        auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
+#endif
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
+    }
+
+    __m128i ctrl;
+};
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif  // PHMAP_HAVE_SSE2
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+struct GroupPortableImpl 
+{
+    enum { kWidth = 8 };
+
+    explicit GroupPortableImpl(const ctrl_t* pos)
+        : ctrl(little_endian::Load64(pos)) {}
+
+    BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
+        // For the technique, see:
+        // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
+        // (Determine if a word has a byte equal to n).
+        //
+        // Caveat: there are false positives but:
+        // - they only occur if there is a real match
+        // - they never occur on kEmpty, kDeleted, kSentinel
+        // - they will be handled gracefully by subsequent checks in code
+        //
+        // Example:
+        //   v = 0x1716151413121110
+        //   hash = 0x12
+        //   retval = (v - lsbs) & ~v & msbs = 0x0000000080800000
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        constexpr uint64_t lsbs = 0x0101010101010101ULL;
+        auto x = ctrl ^ (lsbs * hash);
+        return BitMask<uint64_t, kWidth, 3>((x - lsbs) & ~x & msbs);
+    }
+
+    BitMask<uint64_t, kWidth, 3> MatchEmpty() const {          // bit 1 of each byte is 0 for empty (but not for deleted)
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        return BitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 6)) & msbs);
+    }
+
+    BitMask<uint64_t, kWidth, 3> MatchEmptyOrDeleted() const { // lsb of each byte is 0 for empty or deleted
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        return BitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 7)) & msbs);
+    }
+
+    uint32_t CountLeadingEmptyOrDeleted() const {
+        constexpr uint64_t gaps = 0x00FEFEFEFEFEFEFEULL;
+        return (uint32_t)((TrailingZeros(((~ctrl & (ctrl >> 7)) | gaps) + 1) + 7) >> 3);
+    }
+
+    void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        constexpr uint64_t lsbs = 0x0101010101010101ULL;
+        auto x = ctrl & msbs;
+        auto res = (~x + (x >> 7)) & ~lsbs;
+        little_endian::Store64(dst, res);
+    }
+
+    uint64_t ctrl;
+};
+
+#if PHMAP_HAVE_SSE2  
+    using Group = GroupSse2Impl;
+#else
+    using Group = GroupPortableImpl;
+#endif
+
+// The number of cloned control bytes that we copy from the beginning to the
+// end of the control bytes array.
+// -------------------------------------------------------------------------
+constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
+
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set;
+
+inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
+
+// --------------------------------------------------------------------------
+// PRECONDITION:
+//   IsValidCapacity(capacity)
+//   ctrl[capacity] == kSentinel
+//   ctrl[i] != kSentinel for all i < capacity
+// Applies mapping for every byte in ctrl:
+//   DELETED -> EMPTY
+//   EMPTY -> EMPTY
+//   FULL -> DELETED
+// --------------------------------------------------------------------------
+inline void ConvertDeletedToEmptyAndFullToDeleted(
+    ctrl_t* ctrl, size_t capacity) 
+{
+    assert(ctrl[capacity] == kSentinel);
+    assert(IsValidCapacity(capacity));
+    for (ctrl_t* pos = ctrl; pos != ctrl + capacity + 1; pos += Group::kWidth) {
+        Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
+    }
+    // Copy the cloned ctrl bytes.
+    std::memcpy(ctrl + capacity + 1, ctrl, Group::kWidth);
+    ctrl[capacity] = kSentinel;
+}
+
+// --------------------------------------------------------------------------
+// Rounds up the capacity to the next power of 2 minus 1, with a minimum of 1.
+// --------------------------------------------------------------------------
+inline size_t NormalizeCapacity(size_t n) 
+{
+    return n ? ~size_t{} >> LeadingZeros(n) : 1;
+}
+
+// --------------------------------------------------------------------------
+// We use 7/8th as maximum load factor.
+// For 16-wide groups, that gives an average of two empty slots per group.
+// --------------------------------------------------------------------------
+inline size_t CapacityToGrowth(size_t capacity) 
+{
+    assert(IsValidCapacity(capacity));
+    // `capacity*7/8`
+    PHMAP_IF_CONSTEXPR (Group::kWidth == 8) {
+        if (capacity == 7)
+        {
+            // x-x/8 does not work when x==7.
+            return 6;
+        }
+    }
+    return capacity - capacity / 8;
+}
+
+// --------------------------------------------------------------------------
+// From desired "growth" to a lowerbound of the necessary capacity.
+// Might not be a valid one and required NormalizeCapacity().
+// --------------------------------------------------------------------------
+inline size_t GrowthToLowerboundCapacity(size_t growth) 
+{
+    // `growth*8/7`
+    PHMAP_IF_CONSTEXPR (Group::kWidth == 8) {
+        if (growth == 7)
+        {
+            // x+(x-1)/7 does not work when x==7.
+            return 8;
+        }
+    }
+    return growth + static_cast<size_t>((static_cast<int64_t>(growth) - 1) / 7);
+}
+
+namespace hashtable_debug_internal {
+
+// If it is a map, call get<0>().
+using std::get;
+template <typename T, typename = typename T::mapped_type>
+auto GetKey(const typename T::value_type& pair, int) -> decltype(get<0>(pair)) {
+    return get<0>(pair);
+}
+
+// If it is not a map, return the value directly.
+template <typename T>
+const typename T::key_type& GetKey(const typename T::key_type& key, char) {
+    return key;
+}
+
+// --------------------------------------------------------------------------
+// Containers should specialize this to provide debug information for that
+// container.
+// --------------------------------------------------------------------------
+template <class Container, typename Enabler = void>
+struct HashtableDebugAccess
+{
+    // Returns the number of probes required to find `key` in `c`.  The "number of
+    // probes" is a concept that can vary by container.  Implementations should
+    // return 0 when `key` was found in the minimum number of operations and
+    // should increment the result for each non-trivial operation required to find
+    // `key`.
+    //
+    // The default implementation uses the bucket api from the standard and thus
+    // works for `std::unordered_*` containers.
+    // --------------------------------------------------------------------------
+    static size_t GetNumProbes(const Container& c,
+                               const typename Container::key_type& key) {
+        if (!c.bucket_count()) return {};
+        size_t num_probes = 0;
+        size_t bucket = c.bucket(key);
+        for (auto it = c.begin(bucket), e = c.end(bucket);; ++it, ++num_probes) {
+            if (it == e) return num_probes;
+            if (c.key_eq()(key, GetKey<Container>(*it, 0))) return num_probes;
+        }
+    }
+};
+
+}  // namespace hashtable_debug_internal
+
+// ----------------------------------------------------------------------------
+//                    I N F O Z   S T U B S
+// ----------------------------------------------------------------------------
+struct HashtablezInfo 
+{
+    void PrepareForSampling() {}
+};
+
+inline void RecordRehashSlow(HashtablezInfo*, size_t ) {}
+
+static inline void RecordInsertSlow(HashtablezInfo* , size_t, size_t ) {}
+
+static inline void RecordEraseSlow(HashtablezInfo*) {}
+
+static inline HashtablezInfo* SampleSlow(int64_t*) { return nullptr; }
+static inline void UnsampleSlow(HashtablezInfo* ) {}
+
+class HashtablezInfoHandle 
+{
+public:
+    inline void RecordStorageChanged(size_t , size_t ) {}
+    inline void RecordRehash(size_t ) {}
+    inline void RecordInsert(size_t , size_t ) {}
+    inline void RecordErase() {}
+    friend inline void swap(HashtablezInfoHandle& ,
+                            HashtablezInfoHandle& ) noexcept {}
+};
+
+static inline HashtablezInfoHandle Sample() { return HashtablezInfoHandle(); }
+
+class HashtablezSampler 
+{
+public:
+    // Returns a global Sampler.
+    static HashtablezSampler& Global() {  static HashtablezSampler hzs; return hzs; }
+    HashtablezInfo* Register() {  static HashtablezInfo info; return &info; }
+    void Unregister(HashtablezInfo* ) {}
+
+    using DisposeCallback = void (*)(const HashtablezInfo&);
+    DisposeCallback SetDisposeCallback(DisposeCallback ) { return nullptr; }
+    int64_t Iterate(const std::function<void(const HashtablezInfo& stack)>& ) { return 0; }
+};
+
+static inline void SetHashtablezEnabled(bool ) {}
+static inline void SetHashtablezSampleParameter(int32_t ) {}
+static inline void SetHashtablezMaxSamples(int32_t ) {}
+
+
+namespace memory_internal {
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+// ----------------------------------------------------------------------------
+template <class Alloc, class T, class Tuple, size_t... I>
+void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t,
+                            phmap::index_sequence<I...>) {
+    phmap::allocator_traits<Alloc>::construct(
+        *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...);
+}
+
+template <class T, class F>
+struct WithConstructedImplF {
+    template <class... Args>
+    decltype(std::declval<F>()(std::declval<T>())) operator()(
+        Args&&... args) const {
+        return std::forward<F>(f)(T(std::forward<Args>(args)...));
+    }
+    F&& f;
+};
+
+template <class T, class Tuple, size_t... Is, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
+    Tuple&& t, phmap::index_sequence<Is...>, F&& f) {
+    return WithConstructedImplF<T, F>{std::forward<F>(f)}(
+        std::get<Is>(std::forward<Tuple>(t))...);
+}
+
+template <class T, size_t... Is>
+auto TupleRefImpl(T&& t, phmap::index_sequence<Is...>)
+    -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
+  return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
+}
+
+// Returns a tuple of references to the elements of the input tuple. T must be a
+// tuple.
+// ----------------------------------------------------------------------------
+template <class T>
+auto TupleRef(T&& t) -> decltype(
+    TupleRefImpl(std::forward<T>(t),
+                 phmap::make_index_sequence<
+                     std::tuple_size<typename std::decay<T>::type>::value>())) {
+  return TupleRefImpl(
+      std::forward<T>(t),
+      phmap::make_index_sequence<
+          std::tuple_size<typename std::decay<T>::type>::value>());
+}
+
+template <class F, class K, class V>
+decltype(std::declval<F>()(std::declval<const K&>(), std::piecewise_construct,
+                           std::declval<std::tuple<K>>(), std::declval<V>()))
+DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
+    const auto& key = std::get<0>(p.first);
+    return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
+                              std::move(p.second));
+}
+
+}  // namespace memory_internal
+
+
+// ----------------------------------------------------------------------------
+//                     R A W _ H A S H _ S E T
+// ----------------------------------------------------------------------------
+// An open-addressing
+// hashtable with quadratic probing.
+//
+// This is a low level hashtable on top of which different interfaces can be
+// implemented, like flat_hash_set, node_hash_set, string_hash_set, etc.
+//
+// The table interface is similar to that of std::unordered_set. Notable
+// differences are that most member functions support heterogeneous keys when
+// BOTH the hash and eq functions are marked as transparent. They do so by
+// providing a typedef called `is_transparent`.
+//
+// When heterogeneous lookup is enabled, functions that take key_type act as if
+// they have an overload set like:
+//
+//   iterator find(const key_type& key);
+//   template <class K>
+//   iterator find(const K& key);
+//
+//   size_type erase(const key_type& key);
+//   template <class K>
+//   size_type erase(const K& key);
+//
+//   std::pair<iterator, iterator> equal_range(const key_type& key);
+//   template <class K>
+//   std::pair<iterator, iterator> equal_range(const K& key);
+//
+// When heterogeneous lookup is disabled, only the explicit `key_type` overloads
+// exist.
+//
+// find() also supports passing the hash explicitly:
+//
+//   iterator find(const key_type& key, size_t hash);
+//   template <class U>
+//   iterator find(const U& key, size_t hash);
+//
+// In addition the pointer to element and iterator stability guarantees are
+// weaker: all iterators and pointers are invalidated after a new element is
+// inserted.
+//
+// IMPLEMENTATION DETAILS
+//
+// The table stores elements inline in a slot array. In addition to the slot
+// array the table maintains some control state per slot. The extra state is one
+// byte per slot and stores empty or deleted marks, or alternatively 7 bits from
+// the hash of an occupied slot. The table is split into logical groups of
+// slots, like so:
+//
+//      Group 1         Group 2        Group 3
+// +---------------+---------------+---------------+
+// | | | | | | | | | | | | | | | | | | | | | | | | |
+// +---------------+---------------+---------------+
+//
+// On lookup the hash is split into two parts:
+// - H2: 7 bits (those stored in the control bytes)
+// - H1: the rest of the bits
+// The groups are probed using H1. For each group the slots are matched to H2 in
+// parallel. Because H2 is 7 bits (128 states) and the number of slots per group
+// is low (8 or 16) in almost all cases a match in H2 is also a lookup hit.
+//
+// On insert, once the right group is found (as in lookup), its slots are
+// filled in order.
+//
+// On erase a slot is cleared. In case the group did not have any empty slots
+// before the erase, the erased slot is marked as deleted.
+//
+// Groups without empty slots (but maybe with deleted slots) extend the probe
+// sequence. The probing algorithm is quadratic. Given N the number of groups,
+// the probing function for the i'th probe is:
+//
+//   P(0) = H1 % N
+//
+//   P(i) = (P(i - 1) + i) % N
+//
+// This probing function guarantees that after N probes, all the groups of the
+// table will be probed exactly once.
+// ----------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set 
+{
+    using PolicyTraits = hash_policy_traits<Policy>;
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+public:
+    using init_type = typename PolicyTraits::init_type;
+    using key_type = typename PolicyTraits::key_type;
+    // TODO(sbenza): Hide slot_type as it is an implementation detail. Needs user
+    // code fixes!
+    using slot_type = typename PolicyTraits::slot_type;
+    using allocator_type = Alloc;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using hasher = Hash;
+    using key_equal = Eq;
+    using policy_type = Policy;
+    using value_type = typename PolicyTraits::value_type;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::pointer;
+    using const_pointer = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+    // Alias used for heterogeneous lookup functions.
+    // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+    // `key_type` otherwise. It permits template argument deduction on `K` for the
+    // transparent case.
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+private:
+    // Give an early error when key_type is not hashable/eq.
+    auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+    auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));
+
+    using Layout = phmap::priv::Layout<ctrl_t, slot_type>;
+
+    static Layout MakeLayout(size_t capacity) {
+        assert(IsValidCapacity(capacity));
+        return Layout(capacity + Group::kWidth + 1, capacity);
+    }
+
+    using AllocTraits = phmap::allocator_traits<allocator_type>;
+    using SlotAlloc = typename phmap::allocator_traits<
+        allocator_type>::template rebind_alloc<slot_type>;
+    using SlotAllocTraits = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<slot_type>;
+
+    static_assert(std::is_lvalue_reference<reference>::value,
+                  "Policy::element() must return a reference");
+
+    template <typename T>
+    struct SameAsElementReference
+        : std::is_same<typename std::remove_cv<
+                           typename std::remove_reference<reference>::type>::type,
+                       typename std::remove_cv<
+                           typename std::remove_reference<T>::type>::type> {};
+
+    // An enabler for insert(T&&): T must be convertible to init_type or be the
+    // same as [cv] value_type [ref].
+    // Note: we separate SameAsElementReference into its own type to avoid using
+    // reference unless we need to. MSVC doesn't seem to like it in some
+    // cases.
+    template <class T>
+    using RequiresInsertable = typename std::enable_if<
+        phmap::disjunction<std::is_convertible<T, init_type>,
+                           SameAsElementReference<T>>::value,
+        int>::type;
+
+    // RequiresNotInit is a workaround for gcc prior to 7.1.
+    // See https://godbolt.org/g/Y4xsUh.
+    template <class T>
+    using RequiresNotInit =
+        typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+    template <class... Ts>
+    using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+public:
+    static_assert(std::is_same<pointer, value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+    static_assert(std::is_same<const_pointer, const value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+
+    class iterator 
+    {
+        friend class raw_hash_set;
+
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename raw_hash_set::value_type;
+        using reference =
+            phmap::conditional_t<PolicyTraits::constant_iterators::value,
+                                 const value_type&, value_type&>;
+        using pointer = phmap::remove_reference_t<reference>*;
+        using difference_type = typename raw_hash_set::difference_type;
+
+        iterator() {}
+
+        // PRECONDITION: not an end() iterator.
+        reference operator*() const { return PolicyTraits::element(slot_); }
+
+        // PRECONDITION: not an end() iterator.
+        pointer operator->() const { return &operator*(); }
+
+        // PRECONDITION: not an end() iterator.
+        iterator& operator++() {
+            ++ctrl_;
+            ++slot_;
+            skip_empty_or_deleted();
+            return *this;
+        }
+        // PRECONDITION: not an end() iterator.
+        iterator operator++(int) {
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+#if PHMAP_BIDIRECTIONAL
+        // PRECONDITION: not a begin() iterator.
+        iterator& operator--() {
+            assert(ctrl_);
+            do {
+                --ctrl_;
+                --slot_;
+            } while (IsEmptyOrDeleted(*ctrl_));
+            return *this;
+        }
+
+        // PRECONDITION: not a begin() iterator.
+        iterator operator--(int) {
+            auto tmp = *this;
+            --*this;
+            return tmp;
+        }
+#endif
+
+        friend bool operator==(const iterator& a, const iterator& b) {
+            return a.ctrl_ == b.ctrl_;
+        }
+        friend bool operator!=(const iterator& a, const iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        iterator(ctrl_t* ctrl) : ctrl_(ctrl) {}  // for end()
+        iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {}
+
+        void skip_empty_or_deleted() {
+            while (IsEmptyOrDeleted(*ctrl_)) {
+                // ctrl is not necessarily aligned to Group::kWidth. It is also likely
+                // to read past the space for ctrl bytes and into slots. This is ok
+                // because ctrl has sizeof() == 1 and slot has sizeof() >= 1 so there
+                // is no way to read outside the combined slot array.
+                uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
+                ctrl_ += shift;
+                slot_ += shift;
+            }
+        }
+
+        ctrl_t* ctrl_ = nullptr;
+        // To avoid uninitialized member warnings, put slot_ in an anonymous union.
+        // The member is not initialized on singleton and end iterators.
+        union {
+            slot_type* slot_;
+        };
+    };
+
+    class const_iterator 
+    {
+        friend class raw_hash_set;
+
+    public:
+        using iterator_category = typename iterator::iterator_category;
+        using value_type = typename raw_hash_set::value_type;
+        using reference = typename raw_hash_set::const_reference;
+        using pointer = typename raw_hash_set::const_pointer;
+        using difference_type = typename raw_hash_set::difference_type;
+
+        const_iterator() {}
+        // Implicit construction from iterator.
+        const_iterator(iterator i) : inner_(std::move(i)) {}
+
+        reference operator*() const { return *inner_; }
+        pointer operator->() const { return inner_.operator->(); }
+
+        const_iterator& operator++() {
+            ++inner_;
+            return *this;
+        }
+        const_iterator operator++(int) { return inner_++; }
+
+        friend bool operator==(const const_iterator& a, const const_iterator& b) {
+            return a.inner_ == b.inner_;
+        }
+        friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        const_iterator(const ctrl_t* ctrl, const slot_type* slot)
+            : inner_(const_cast<ctrl_t*>(ctrl), const_cast<slot_type*>(slot)) {}
+
+        iterator inner_;
+    };
+
+    using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+    using insert_return_type = InsertReturnType<iterator, node_type>;
+
+    raw_hash_set() noexcept(
+        std::is_nothrow_default_constructible<hasher>::value&&
+        std::is_nothrow_default_constructible<key_equal>::value&&
+        std::is_nothrow_default_constructible<allocator_type>::value) {}
+
+    explicit raw_hash_set(size_t bucket_cnt, const hasher& hashfn = hasher(),
+                          const key_equal& eq = key_equal(),
+                          const allocator_type& alloc = allocator_type())
+        : ctrl_(EmptyGroup()), settings_(0, hashfn, eq, alloc) {
+        if (bucket_cnt) {
+            size_t new_capacity = NormalizeCapacity(bucket_cnt);
+            reset_growth_left(new_capacity);
+            initialize_slots(new_capacity);
+            capacity_ = new_capacity;
+        }
+    }
+
+    raw_hash_set(size_t bucket_cnt, const hasher& hashfn,
+                 const allocator_type& alloc)
+        : raw_hash_set(bucket_cnt, hashfn, key_equal(), alloc) {}
+
+    raw_hash_set(size_t bucket_cnt, const allocator_type& alloc)
+        : raw_hash_set(bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    explicit raw_hash_set(const allocator_type& alloc)
+        : raw_hash_set(0, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_cnt = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(bucket_cnt, hashfn, eq, alloc) {
+        insert(first, last);
+    }
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_cnt,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(first, last, bucket_cnt, hashfn, key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_cnt,
+                 const allocator_type& alloc)
+        : raw_hash_set(first, last, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
+        : raw_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
+
+    // Instead of accepting std::initializer_list<value_type> as the first
+    // argument like std::unordered_set<value_type> does, we have two overloads
+    // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+    // This is advantageous for performance.
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then
+    //   // copies the strings into the set.
+    //   std::unordered_set<std::string> s = {"abc", "def"};
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+    //   // copies the strings into the set.
+    //   phmap::flat_hash_set<std::string> s = {"abc", "def"};
+    //
+    // The same trick is used in insert().
+    //
+    // The enabler is necessary to prevent this constructor from triggering where
+    // the copy constructor is meant to be called.
+    //
+    //   phmap::flat_hash_set<int> a, b{a};
+    //
+    // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_cnt = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(init.begin(), init.end(), bucket_cnt, hashfn, eq, alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(init.begin(), init.end(), bucket_cnt, hashfn, eq, alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_cnt,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(init, bucket_cnt, hashfn, key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(init, bucket_cnt, hashfn, key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_cnt,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
+        : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(const raw_hash_set& that)
+        : raw_hash_set(that, AllocTraits::select_on_container_copy_construction(
+                           that.alloc_ref())) {}
+
+    raw_hash_set(const raw_hash_set& that, const allocator_type& a)
+        : raw_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
+        rehash(that.capacity());   // operator=() should preserve load_factor
+        // Because the table is guaranteed to be empty, we can do something faster
+        // than a full `insert`.
+        for (const auto& v : that) {
+            const size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, v);
+            auto target = find_first_non_full(hashval);
+            set_ctrl(target.offset, H2(hashval));
+            emplace_at(target.offset, v);
+            infoz_.RecordInsert(hashval, target.probe_length);
+        }
+        size_ = that.size();
+        growth_left() -= that.size();
+    }
+
+    raw_hash_set(raw_hash_set&& that) noexcept(
+        std::is_nothrow_copy_constructible<hasher>::value&&
+        std::is_nothrow_copy_constructible<key_equal>::value&&
+        std::is_nothrow_copy_constructible<allocator_type>::value)
+        : ctrl_(phmap::exchange(that.ctrl_, EmptyGroup())),
+        slots_(phmap::exchange(that.slots_, nullptr)),
+        size_(phmap::exchange(that.size_, 0)),
+        capacity_(phmap::exchange(that.capacity_, 0)),
+        infoz_(phmap::exchange(that.infoz_, HashtablezInfoHandle())),
+    // Hash, equality and allocator are copied instead of moved because
+    // `that` must be left valid. If Hash is std::function<Key>, moving it
+    // would create a nullptr functor that cannot be called.
+        settings_(that.settings_) {
+        // growth_left was copied above, reset the one from `that`.
+        that.growth_left() = 0;
+    }
+
+    raw_hash_set(raw_hash_set&& that, const allocator_type& a)
+        : ctrl_(EmptyGroup()),
+          slots_(nullptr),
+          size_(0),
+          capacity_(0),
+          settings_(0, that.hash_ref(), that.eq_ref(), a) {
+        if (a == that.alloc_ref()) {
+            std::swap(ctrl_, that.ctrl_);
+            std::swap(slots_, that.slots_);
+            std::swap(size_, that.size_);
+            std::swap(capacity_, that.capacity_);
+            std::swap(growth_left(), that.growth_left());
+            std::swap(infoz_, that.infoz_);
+        } else {
+            reserve(that.size());
+            // Note: this will copy elements of dense_set and unordered_set instead of
+            // moving them. This can be fixed if it ever becomes an issue.
+            for (auto& elem : that) insert(std::move(elem));
+        }
+    }
+
+    raw_hash_set& operator=(const raw_hash_set& that) {
+        raw_hash_set tmp(that,
+                         AllocTraits::propagate_on_container_copy_assignment::value
+                         ? that.alloc_ref()
+                         : alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+    raw_hash_set& operator=(raw_hash_set&& that) noexcept(
+        phmap::allocator_traits<allocator_type>::is_always_equal::value&&
+        std::is_nothrow_move_assignable<hasher>::value&&
+        std::is_nothrow_move_assignable<key_equal>::value) {
+        // TODO(sbenza): We should only use the operations from the noexcept clause
+        // to make sure we actually adhere to that contract.
+        return move_assign(
+            std::move(that),
+            typename AllocTraits::propagate_on_container_move_assignment());
+    }
+
+    ~raw_hash_set() { destroy_slots(); }
+
+    iterator begin() {
+        auto it = iterator_at(0);
+        it.skip_empty_or_deleted();
+        return it;
+    }
+    iterator end() 
+    {
+#if PHMAP_BIDIRECTIONAL
+        return iterator_at(capacity_); 
+#else
+        return {ctrl_ + capacity_};
+#endif
+    }
+
+    const_iterator begin() const {
+        return const_cast<raw_hash_set*>(this)->begin();
+    }
+    const_iterator end() const { return const_cast<raw_hash_set*>(this)->end(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend() const { return end(); }
+
+    bool empty() const { return !size(); }
+    size_t size() const { return size_; }
+    size_t capacity() const { return capacity_; }
+    size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
+
+    PHMAP_ATTRIBUTE_REINITIALIZES void clear() {
+        // Iterating over this container is O(bucket_count()). When bucket_count()
+        // is much greater than size(), iteration becomes prohibitively expensive.
+        // For clear() it is more important to reuse the allocated array when the
+        // container is small because allocation takes comparatively long time
+        // compared to destruction of the elements of the container. So we pick the
+        // largest bucket_count() threshold for which iteration is still fast and
+        // past that we simply deallocate the array.
+        if (empty())
+            return;
+        if (capacity_ > 127) {
+            destroy_slots();
+        } else if (capacity_) {
+            for (size_t i = 0; i != capacity_; ++i) {
+                if (IsFull(ctrl_[i])) {
+                    PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+                }
+            }
+            size_ = 0;
+            reset_ctrl(capacity_);
+            reset_growth_left(capacity_);
+        }
+        assert(empty());
+        infoz_.RecordStorageChanged(0, capacity_);
+    }
+
+    // This overload kicks in when the argument is an rvalue of insertable and
+    // decomposable type other than init_type.
+    //
+    //   flat_hash_map<std::string, int> m;
+    //   m.insert(std::make_pair("abc", 42));
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    std::pair<iterator, bool> insert(T&& value) {
+        return emplace(std::forward<T>(value));
+    }
+
+    // This overload kicks in when the argument is a bitfield or an lvalue of
+    // insertable and decomposable type.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_set<int> s;
+    //   s.insert(n);
+    //
+    //   flat_hash_set<std::string> s;
+    //   const char* p = "hello";
+    //   s.insert(p);
+    //
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    std::pair<iterator, bool> insert(const T& value) {
+        return emplace(value);
+    }
+
+    // This overload kicks in when the argument is an rvalue of init_type. Its
+    // purpose is to handle brace-init-list arguments.
+    //
+    //   flat_hash_set<std::string, int> s;
+    //   s.insert({"abc", 42});
+    std::pair<iterator, bool> insert(init_type&& value) {
+        return emplace(std::move(value));
+    }
+
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    iterator insert(const_iterator, T&& value) {
+        return insert(std::forward<T>(value)).first;
+    }
+
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    iterator insert(const_iterator, const T& value) {
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, init_type&& value) {
+        return insert(std::move(value)).first;
+    }
+
+    template <typename It>
+    using IsRandomAccess = std::is_same<typename std::iterator_traits<It>::iterator_category,
+                                        std::random_access_iterator_tag>;
+
+
+    template<typename T>
+    struct has_difference_operator
+    {
+    private:
+        using yes = std::true_type;
+        using no  = std::false_type;
+ 
+        template<typename U> static auto test(int) -> decltype(std::declval<U>() - std::declval<U>() == 1, yes());
+        template<typename>   static no   test(...);
+ 
+    public:
+        static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
+    };
+
+    template <class InputIt, typename phmap::enable_if_t<has_difference_operator<InputIt>::value, int> = 0>
+    void insert(InputIt first, InputIt last) {
+        this->reserve(this->size() + (last - first));
+        for (; first != last; ++first) 
+            emplace(*first);
+    }
+
+    template <class InputIt, typename phmap::enable_if_t<!has_difference_operator<InputIt>::value, int> = 0>
+    void insert(InputIt first, InputIt last) {
+        for (; first != last; ++first) 
+            emplace(*first);
+    }
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+    void insert(std::initializer_list<T> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    void insert(std::initializer_list<init_type> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    insert_return_type insert(node_type&& node) {
+        if (!node) return {end(), false, node_type()};
+        const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+        auto res = PolicyTraits::apply(
+            InsertSlot<false>{*this, std::move(*CommonAccess::GetSlot(node))},
+            elem);
+        if (res.second) {
+            CommonAccess::Reset(&node);
+            return {res.first, true, node_type()};
+        } else {
+            return {res.first, false, std::move(node)};
+        }
+    }
+
+    insert_return_type insert(node_type&& node, size_t hashval) {
+        if (!node) return {end(), false, node_type()};
+        const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+        auto res = PolicyTraits::apply(
+            InsertSlotWithHash<false>{*this, std::move(*CommonAccess::GetSlot(node)), hashval},
+            elem);
+        if (res.second) {
+            CommonAccess::Reset(&node);
+            return {res.first, true, node_type()};
+        } else {
+            return {res.first, false, std::move(node)};
+        }
+    }
+
+    iterator insert(const_iterator, node_type&& node) {
+        auto res = insert(std::move(node));
+        node = std::move(res.node);
+        return res.position;
+    }
+
+    // This overload kicks in if we can deduce the key from args. This enables us
+    // to avoid constructing value_type if an entry with the same key already
+    // exists.
+    //
+    // For example:
+    //
+    //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+    //   // Creates no std::string copies and makes no heap allocations.
+    //   m.emplace("abc", "xyz");
+    template <class... Args, typename std::enable_if<
+                                 IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposable{*this},
+                                   std::forward<Args>(args)...);
+    }
+
+    template <class... Args, typename std::enable_if<IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace_with_hash(size_t hashval, Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposableHashval{*this, hashval}, std::forward<Args>(args)...);
+    }
+
+    // This overload kicks in if we cannot deduce the key from args. It constructs
+    // value_type unconditionally and then either moves it into the table or
+    // destroys.
+    template <class... Args, typename std::enable_if<
+                                 !IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        typename phmap::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type
+            raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        return PolicyTraits::apply(InsertSlot<true>{*this, std::move(*slot)}, elem);
+    }
+
+    template <class... Args, typename std::enable_if<!IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace_with_hash(size_t hashval, Args&&... args) {
+        typename phmap::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        return PolicyTraits::apply(InsertSlotWithHash<true>{*this, std::move(*slot), hashval}, elem);
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    template <class... Args>
+    iterator emplace_hint_with_hash(size_t hashval, const_iterator, Args&&... args) {
+        return emplace_with_hash(hashval, std::forward<Args>(args)...).first;
+    }
+
+    // Extension API: support for lazy emplace.
+    //
+    // Looks up key in the table. If found, returns the iterator to the element.
+    // Otherwise calls f with one argument of type raw_hash_set::constructor. f
+    // MUST call raw_hash_set::constructor with arguments as if a
+    // raw_hash_set::value_type is constructed, otherwise the behavior is
+    // undefined.
+    //
+    // For example:
+    //
+    //   std::unordered_set<ArenaString> s;
+    //   // Makes ArenaStr even if "abc" is in the map.
+    //   s.insert(ArenaString(&arena, "abc"));
+    //
+    //   flat_hash_set<ArenaStr> s;
+    //   // Makes ArenaStr only if "abc" is not in the map.
+    //   s.lazy_emplace("abc", [&](const constructor& ctor) {
+    //     ctor(&arena, "abc");
+    //   });
+    //
+    // WARNING: This API is currently experimental. If there is a way to implement
+    // the same thing with the rest of the API, prefer that.
+    class constructor 
+    {
+        friend class raw_hash_set;
+
+    public:
+        template <class... Args>
+        void operator()(Args&&... args) const {
+            assert(*slot_);
+            PolicyTraits::construct(alloc_, *slot_, std::forward<Args>(args)...);
+            *slot_ = nullptr;
+        }
+
+    private:
+        constructor(allocator_type* a, slot_type** slot) : alloc_(a), slot_(slot) {}
+
+        allocator_type* alloc_;
+        slot_type** slot_;
+    };
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace(const key_arg<K>& key, F&& f) {
+        auto res = find_or_prepare_insert(key);
+        if (res.second) {
+            lazy_emplace_at(res.first, std::forward<F>(f));
+        }
+        return iterator_at(res.first);
+    }
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace_with_hash(const key_arg<K>& key, size_t hashval, F&& f) {
+        auto res = find_or_prepare_insert(key, hashval);
+        if (res.second) {
+            lazy_emplace_at(res.first, std::forward<F>(f));
+        }
+        return iterator_at(res.first);
+    }
+
+    template <class K = key_type, class F>
+    void lazy_emplace_at(size_t& idx, F&& f) {
+        slot_type* slot = slots_ + idx;
+        std::forward<F>(f)(constructor(&alloc_ref(), &slot));
+        assert(!slot);
+    }
+
+    template <class K = key_type, class F>
+    void emplace_single_with_hash(const key_arg<K>& key, size_t hashval, F&& f) {
+        auto res = find_or_prepare_insert(key, hashval);
+        if (res.second)
+            lazy_emplace_at(res.first, std::forward<F>(f));
+        else
+            _erase(iterator_at(res.first));
+    }
+
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.erase("abc");
+    //
+    //   flat_hash_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.erase("abc");
+    template <class K = key_type>
+    size_type erase(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it == end()) return 0;
+        _erase(it);
+        return 1;
+    }
+
+
+    iterator erase(const_iterator cit) { return erase(cit.inner_); }
+    
+    // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+    // this method returns void to reduce algorithmic complexity to O(1).  In
+    // order to erase while iterating across a map, use the following idiom (which
+    // also works for standard containers):
+    //
+    // for (auto it = m.begin(), end = m.end(); it != end;) {
+    //   if (<pred>) {
+    //     m._erase(it++);
+    //   } else {
+    //     ++it;
+    //   }
+    // }
+    void _erase(iterator it) {
+        assert(it != end());
+        PolicyTraits::destroy(&alloc_ref(), it.slot_);
+        erase_meta_only(it);
+    }
+    void _erase(const_iterator cit) { _erase(cit.inner_); }
+
+    // This overload is necessary because otherwise erase<K>(const K&) would be
+    // a better match if non-const iterator is passed as an argument.
+    iterator erase(iterator it) {
+        auto res = it;
+        ++res;
+        _erase(it);
+        return res;
+    }
+
+    iterator erase(const_iterator first, const_iterator last) {
+        while (first != last) {
+            _erase(first++);
+        }
+        return last.inner_;
+    }
+
+    // Moves elements from `src` into `this`.
+    // If the element already exists in `this`, it is left unmodified in `src`.
+    template <typename H, typename E>
+    void merge(raw_hash_set<Policy, H, E, Alloc>& src) {  // NOLINT
+        assert(this != &src);
+        for (auto it = src.begin(), e = src.end(); it != e; ++it) {
+            if (PolicyTraits::apply(InsertSlot<false>{*this, std::move(*it.slot_)},
+                                    PolicyTraits::element(it.slot_))
+                .second) {
+                src.erase_meta_only(it);
+            }
+        }
+    }
+
+    template <typename H, typename E>
+    void merge(raw_hash_set<Policy, H, E, Alloc>&& src) {
+        merge(src);
+    }
+
+    node_type extract(const_iterator position) {
+        auto node =
+            CommonAccess::Make<node_type>(alloc_ref(), position.inner_.slot_);
+        erase_meta_only(position);
+        return node;
+    }
+
+    template <
+        class K = key_type,
+        typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+    node_type extract(const key_arg<K>& key) {
+        auto it = find(key);
+        return it == end() ? node_type() : extract(const_iterator{it});
+    }
+
+    void swap(raw_hash_set& that) noexcept(
+        IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
+        (!AllocTraits::propagate_on_container_swap::value ||
+         IsNoThrowSwappable<allocator_type>())) {
+        using std::swap;
+        swap(ctrl_, that.ctrl_);
+        swap(slots_, that.slots_);
+        swap(size_, that.size_);
+        swap(capacity_, that.capacity_);
+        swap(growth_left(), that.growth_left());
+        swap(hash_ref(), that.hash_ref());
+        swap(eq_ref(), that.eq_ref());
+        swap(infoz_, that.infoz_);
+        if (AllocTraits::propagate_on_container_swap::value) {
+            swap(alloc_ref(), that.alloc_ref());
+        } else {
+            // If the allocators do not compare equal it is officially undefined
+            // behavior. We choose to do nothing.
+        }
+    }
+
+#if !defined(PHMAP_NON_DETERMINISTIC)
+    template<typename OutputArchive>
+    bool phmap_dump(OutputArchive&) const;
+
+    template<typename InputArchive>
+    bool  phmap_load(InputArchive&);
+#endif
+
+    void rehash(size_t n) {
+        if (n == 0 && capacity_ == 0) return;
+        if (n == 0 && size_ == 0) {
+            destroy_slots();
+            infoz_.RecordStorageChanged(0, 0);
+            return;
+        }
+        // bitor is a faster way of doing `max` here. We will round up to the next
+        // power-of-2-minus-1, so bitor is good enough.
+        auto m = NormalizeCapacity((std::max)(n, size()));
+        // n == 0 unconditionally rehashes as per the standard.
+        if (n == 0 || m > capacity_) {
+            resize(m);
+        }
+    }
+
+    void reserve(size_t n) { rehash(GrowthToLowerboundCapacity(n)); }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.count("abc");
+    //
+    //   ch_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.count("abc");
+    template <class K = key_type>
+    size_t count(const key_arg<K>& key) const {
+        return find(key) == end() ? size_t(0) : size_t(1);
+    }
+
+    // Issues CPU prefetch instructions for the memory needed to find or insert
+    // a key.  Like all lookup functions, this support heterogeneous keys.
+    //
+    // NOTE: This is a very low level operation and should not be used without
+    // specific benchmarks indicating its importance.
+    void prefetch_hash(size_t hashval) const {
+        (void)hashval;
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
+        auto seq = probe(hashval);
+        _mm_prefetch((const char *)(ctrl_ + seq.offset()), _MM_HINT_NTA);
+        _mm_prefetch((const char *)(slots_ + seq.offset()), _MM_HINT_NTA);
+#elif defined(__GNUC__)
+        auto seq = probe(hashval);
+        __builtin_prefetch(static_cast<const void*>(ctrl_ + seq.offset()));
+        __builtin_prefetch(static_cast<const void*>(slots_ + seq.offset()));
+#endif  // __GNUC__
+    }
+
+    template <class K = key_type>
+    void prefetch(const key_arg<K>& key) const {
+        prefetch_hash(this->hash(key));
+    }
+
+    // The API of find() has two extensions.
+    //
+    // 1. The hash can be passed by the user. It must be equal to the hash of the
+    // key.
+    //
+    // 2. The type of the key argument doesn't have to be key_type. This is so
+    // called heterogeneous key support.
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key, size_t hashval) {
+        size_t offset;
+        if (find_impl(key, hashval, offset))
+            return iterator_at(offset);
+        else
+            return end();
+    }
+
+    template <class K = key_type>
+    pointer find_ptr(const key_arg<K>& key, size_t hashval) {
+        size_t offset;
+        if (find_impl(key, hashval, offset))
+            return &PolicyTraits::element(slots_ + offset);
+        else
+            return nullptr;
+    }
+
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key) {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key, size_t hashval) const {
+        return const_cast<raw_hash_set*>(this)->find(key, hashval);
+    }
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key) const {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key) const {
+        return find(key) != end();
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key, size_t hashval) const {
+        return find(key, hashval) != end();
+    }
+
+    template <class K = key_type>
+    std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+    template <class K = key_type>
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_arg<K>& key) const {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    size_t bucket_count() const { return capacity_; }
+    float load_factor() const {
+        return capacity_ ? static_cast<double>(size()) / capacity_ : 0.0;
+    }
+    float max_load_factor() const { return 1.0f; }
+    void max_load_factor(float) {
+        // Does nothing.
+    }
+
+    hasher hash_function() const { return hash_ref(); } // warning: doesn't match internal hash - use hash() member function
+    key_equal key_eq() const { return eq_ref(); }
+    allocator_type get_allocator() const { return alloc_ref(); }
+
+    friend bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
+        if (a.size() != b.size()) return false;
+        const raw_hash_set* outer = &a;
+        const raw_hash_set* inner = &b;
+        if (outer->capacity() > inner->capacity()) 
+            std::swap(outer, inner);
+        for (const value_type& elem : *outer)
+            if (!inner->has_element(elem)) return false;
+        return true;
+    }
+
+    friend bool operator!=(const raw_hash_set& a, const raw_hash_set& b) {
+        return !(a == b);
+    }
+
+    friend void swap(raw_hash_set& a,
+                     raw_hash_set& b) noexcept(noexcept(a.swap(b))) {
+        a.swap(b);
+    }
+
+    template <class K>
+    size_t hash(const K& key) const {
+        return HashElement{hash_ref()}(key);
+    }
+
+private:
+    template <class Container, typename Enabler>
+    friend struct phmap::priv::hashtable_debug_internal::HashtableDebugAccess;
+
+    template <class K = key_type>
+    bool find_impl(const key_arg<K>& key, size_t hashval, size_t& offset) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ ctrl_ + seq.offset() };
+            for (uint32_t i : g.Match((h2_t)H2(hashval))) {
+                offset = seq.offset((size_t)i);
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
+                    EqualElement<K>{key, eq_ref()},
+                    PolicyTraits::element(slots_ + offset))))
+                    return true;
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty()))
+                return false;
+            seq.next();
+        }
+    }
+
+    struct FindElement 
+    {
+        template <class K, class... Args>
+        const_iterator operator()(const K& key, Args&&...) const {
+            return s.find(key);
+        }
+        const raw_hash_set& s;
+    };
+
+    struct HashElement 
+    {
+        template <class K, class... Args>
+        size_t operator()(const K& key, Args&&...) const {
+            return phmap_mix<sizeof(size_t)>()(h(key));
+        }
+        const hasher& h;
+    };
+
+    template <class K1>
+    struct EqualElement 
+    {
+        template <class K2, class... Args>
+        bool operator()(const K2& lhs, Args&&...) const {
+            return eq(lhs, rhs);
+        }
+        const K1& rhs;
+        const key_equal& eq;
+    };
+
+    template <class K, class... Args>
+    std::pair<iterator, bool> emplace_decomposable(const K& key, size_t hashval, 
+                                                   Args&&... args)
+    {
+        auto res = find_or_prepare_insert(key, hashval);
+        if (res.second) {
+            emplace_at(res.first, std::forward<Args>(args)...);
+        }
+        return {iterator_at(res.first), res.second};
+    }
+
+    struct EmplaceDecomposable 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable(key, s.hash(key), std::forward<Args>(args)...);
+        }
+        raw_hash_set& s;
+    };
+
+    struct EmplaceDecomposableHashval {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable(key, hashval, std::forward<Args>(args)...);
+        }
+        raw_hash_set& s;
+        size_t hashval;
+    };
+
+    template <bool do_destroy>
+    struct InsertSlot 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
+            auto res = s.find_or_prepare_insert(key);
+            if (res.second) {
+                PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+            } else if (do_destroy) {
+                PolicyTraits::destroy(&s.alloc_ref(), &slot);
+            }
+            return {s.iterator_at(res.first), res.second};
+        }
+        raw_hash_set& s;
+        // Constructed slot. Either moved into place or destroyed.
+        slot_type&& slot;
+    };
+
+    template <bool do_destroy>
+    struct InsertSlotWithHash 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
+            auto res = s.find_or_prepare_insert(key, hashval);
+            if (res.second) {
+                PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+            } else if (do_destroy) {
+                PolicyTraits::destroy(&s.alloc_ref(), &slot);
+            }
+            return {s.iterator_at(res.first), res.second};
+        }
+        raw_hash_set& s;
+        // Constructed slot. Either moved into place or destroyed.
+        slot_type&& slot;
+        size_t &hashval;
+    };
+
+    // "erases" the object from the container, except that it doesn't actually
+    // destroy the object. It only updates all the metadata of the class.
+    // This can be used in conjunction with Policy::transfer to move the object to
+    // another place.
+    void erase_meta_only(const_iterator it) {
+        assert(IsFull(*it.inner_.ctrl_) && "erasing a dangling iterator");
+        --size_;
+        const size_t index = (size_t)(it.inner_.ctrl_ - ctrl_);
+        const size_t index_before = (index - Group::kWidth) & capacity_;
+        const auto empty_after = Group(it.inner_.ctrl_).MatchEmpty();
+        const auto empty_before = Group(ctrl_ + index_before).MatchEmpty();
+
+        // We count how many consecutive non empties we have to the right and to the
+        // left of `it`. If the sum is >= kWidth then there is at least one probe
+        // window that might have seen a full group.
+        bool was_never_full =
+            empty_before && empty_after &&
+            static_cast<size_t>(empty_after.TrailingZeros() +
+                                empty_before.LeadingZeros()) < Group::kWidth;
+
+        set_ctrl(index, was_never_full ? kEmpty : kDeleted);
+        growth_left() += was_never_full;
+        infoz_.RecordErase();
+    }
+
+    void initialize_slots(size_t new_capacity) {
+        assert(new_capacity);
+        if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value && 
+            slots_ == nullptr) {
+            infoz_ = Sample();
+        }
+
+        auto layout = MakeLayout(new_capacity);
+        char* mem = static_cast<char*>(
+            Allocate<Layout::Alignment()>(&alloc_ref(), layout.AllocSize()));
+        ctrl_ = reinterpret_cast<ctrl_t*>(layout.template Pointer<0>(mem));
+        slots_ = layout.template Pointer<1>(mem);
+        reset_ctrl(new_capacity);
+        reset_growth_left(new_capacity);
+        infoz_.RecordStorageChanged(size_, new_capacity);
+    }
+
+    void destroy_slots() {
+        if (!capacity_) return;
+        for (size_t i = 0; i != capacity_; ++i) {
+            if (IsFull(ctrl_[i])) {
+                PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+            }
+        }
+        auto layout = MakeLayout(capacity_);
+        // Unpoison before returning the memory to the allocator.
+        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
+        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
+        ctrl_ = EmptyGroup();
+        slots_ = nullptr;
+        size_ = 0;
+        capacity_ = 0;
+        growth_left() = 0;
+    }
+
+    void resize(size_t new_capacity) {
+        assert(IsValidCapacity(new_capacity));
+        auto* old_ctrl = ctrl_;
+        auto* old_slots = slots_;
+        const size_t old_capacity = capacity_;
+        initialize_slots(new_capacity);
+        capacity_ = new_capacity;
+
+        for (size_t i = 0; i != old_capacity; ++i) {
+            if (IsFull(old_ctrl[i])) {
+                size_t hashval = PolicyTraits::apply(HashElement{hash_ref()},
+                                                     PolicyTraits::element(old_slots + i));
+                auto target = find_first_non_full(hashval);
+                size_t new_i = target.offset;
+                set_ctrl(new_i, H2(hashval));
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
+            }
+        }
+        if (old_capacity) {
+            SanitizerUnpoisonMemoryRegion(old_slots,
+                                          sizeof(slot_type) * old_capacity);
+            auto layout = MakeLayout(old_capacity);
+            Deallocate<Layout::Alignment()>(&alloc_ref(), old_ctrl,
+                                            layout.AllocSize());
+        }
+    }
+
+    void drop_deletes_without_resize() PHMAP_ATTRIBUTE_NOINLINE {
+        assert(IsValidCapacity(capacity_));
+        assert(!is_small());
+        // Algorithm:
+        // - mark all DELETED slots as EMPTY
+        // - mark all FULL slots as DELETED
+        // - for each slot marked as DELETED
+        //     hash = Hash(element)
+        //     target = find_first_non_full(hash)
+        //     if target is in the same group
+        //       mark slot as FULL
+        //     else if target is EMPTY
+        //       transfer element to target
+        //       mark slot as EMPTY
+        //       mark target as FULL
+        //     else if target is DELETED
+        //       swap current element with target element
+        //       mark target as FULL
+        //       repeat procedure for current slot with moved from element (target)
+        ConvertDeletedToEmptyAndFullToDeleted(ctrl_, capacity_);
+        typename phmap::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type
+            raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+        for (size_t i = 0; i != capacity_; ++i) {
+            if (!IsDeleted(ctrl_[i])) continue;
+            size_t hashval = PolicyTraits::apply(HashElement{hash_ref()},
+                                                 PolicyTraits::element(slots_ + i));
+            auto target = find_first_non_full(hashval);
+            size_t new_i = target.offset;
+
+            // Verify if the old and new i fall within the same group wrt the hashval.
+            // If they do, we don't need to move the object as it falls already in the
+            // best probe we can.
+            const auto probe_index = [&](size_t pos) {
+                return ((pos - probe(hashval).offset()) & capacity_) / Group::kWidth;
+            };
+
+            // Element doesn't move.
+            if (PHMAP_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
+                set_ctrl(i, H2(hashval));
+                continue;
+            }
+            if (IsEmpty(ctrl_[new_i])) {
+                // Transfer element to the empty spot.
+                // set_ctrl poisons/unpoisons the slots so we have to call it at the
+                // right time.
+                set_ctrl(new_i, H2(hashval));
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slots_ + i);
+                set_ctrl(i, kEmpty);
+            } else {
+                assert(IsDeleted(ctrl_[new_i]));
+                set_ctrl(new_i, H2(hashval));
+                // Until we are done rehashing, DELETED marks previously FULL slots.
+                // Swap i and new_i elements.
+                PolicyTraits::transfer(&alloc_ref(), slot, slots_ + i);
+                PolicyTraits::transfer(&alloc_ref(), slots_ + i, slots_ + new_i);
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slot);
+                --i;  // repeat
+            }
+        }
+        reset_growth_left(capacity_);
+    }
+
+    void rehash_and_grow_if_necessary() {
+        if (capacity_ == 0) {
+            resize(1);
+        } else if (size() <= CapacityToGrowth(capacity()) / 2) {
+            // Squash DELETED without growing if there is enough capacity.
+            drop_deletes_without_resize();
+        } else {
+            // Otherwise grow the container.
+            resize(capacity_ * 2 + 1);
+        }
+    }
+
+    bool has_element(const value_type& elem, size_t hashval) const {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            for (uint32_t i : g.Match((h2_t)H2(hashval))) {
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset((size_t)i)) ==
+                                      elem))
+                    return true;
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) return false;
+            seq.next();
+            assert(seq.getindex() < capacity_ && "full table!");
+        }
+        return false;
+    }
+
+    bool has_element(const value_type& elem) const {
+        size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+        return has_element(elem, hashval);
+    }
+
+    // Probes the raw_hash_set with the probe sequence for hash and returns the
+    // pointer to the first empty or deleted slot.
+    // NOTE: this function must work with tables having both kEmpty and kDelete
+    // in one group. Such tables appears during drop_deletes_without_resize.
+    //
+    // This function is very useful when insertions happen and:
+    // - the input is already a set
+    // - there are enough slots
+    // - the element with the hash is not in the table
+    struct FindInfo 
+    {
+        size_t offset;
+        size_t probe_length;
+    };
+    FindInfo find_first_non_full(size_t hashval) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            auto mask = g.MatchEmptyOrDeleted();
+            if (mask) {
+                return {seq.offset((size_t)mask.LowestBitSet()), seq.getindex()};
+            }
+            assert(seq.getindex() < capacity_ && "full table!");
+            seq.next();
+        }
+    }
+
+    // TODO(alkis): Optimize this assuming *this and that don't overlap.
+    raw_hash_set& move_assign(raw_hash_set&& that, std::true_type) {
+        raw_hash_set tmp(std::move(that));
+        swap(tmp);
+        return *this;
+    }
+    raw_hash_set& move_assign(raw_hash_set&& that, std::false_type) {
+        raw_hash_set tmp(std::move(that), alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+protected:
+    template <class K>
+    std::pair<size_t, bool> find_or_prepare_insert(const K& key, size_t hashval) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            for (uint32_t i : g.Match((h2_t)H2(hashval))) {
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
+                                          EqualElement<K>{key, eq_ref()},
+                                          PolicyTraits::element(slots_ + seq.offset((size_t)i)))))
+                    return {seq.offset((size_t)i), false};
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) break;
+            seq.next();
+        }
+        return {prepare_insert(hashval), true};
+    }
+
+    template <class K>
+    std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
+        return find_or_prepare_insert(key, this->hash(key));
+    }
+
+    size_t prepare_insert(size_t hashval) PHMAP_ATTRIBUTE_NOINLINE {
+        auto target = find_first_non_full(hashval);
+        if (PHMAP_PREDICT_FALSE(growth_left() == 0 &&
+                               !IsDeleted(ctrl_[target.offset]))) {
+            rehash_and_grow_if_necessary();
+            target = find_first_non_full(hashval);
+        }
+        ++size_;
+        growth_left() -= IsEmpty(ctrl_[target.offset]);
+        set_ctrl(target.offset, H2(hashval));
+        infoz_.RecordInsert(hashval, target.probe_length);
+        return target.offset;
+    }
+
+    // Constructs the value in the space pointed by the iterator. This only works
+    // after an unsuccessful find_or_prepare_insert() and before any other
+    // modifications happen in the raw_hash_set.
+    //
+    // PRECONDITION: i is an index returned from find_or_prepare_insert(k), where
+    // k is the key decomposed from `forward<Args>(args)...`, and the bool
+    // returned by find_or_prepare_insert(k) was true.
+    // POSTCONDITION: *m.iterator_at(i) == value_type(forward<Args>(args)...).
+    template <class... Args>
+    void emplace_at(size_t i, Args&&... args) {
+        PolicyTraits::construct(&alloc_ref(), slots_ + i,
+                                std::forward<Args>(args)...);
+        
+#ifdef PHMAP_CHECK_CONSTRUCTED_VALUE
+        // this check can be costly, so do it only when requested
+        assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
+               iterator_at(i) &&
+               "constructed value does not match the lookup key");
+#endif
+    }
+
+    iterator iterator_at(size_t i) { return {ctrl_ + i, slots_ + i}; }
+    const_iterator iterator_at(size_t i) const { return {ctrl_ + i, slots_ + i}; }
+
+private:
+    friend struct RawHashSetTestOnlyAccess;
+
+    probe_seq<Group::kWidth> probe(size_t hashval) const {
+        return probe_seq<Group::kWidth>(H1(hashval, ctrl_), capacity_);
+    }
+
+    // Reset all ctrl bytes back to kEmpty, except the sentinel.
+    void reset_ctrl(size_t capacity) {
+        std::memset(ctrl_, kEmpty, capacity + Group::kWidth);
+        ctrl_[capacity] = kSentinel;
+        SanitizerPoisonMemoryRegion(slots_, sizeof(slot_type) * capacity);
+    }
+
+    void reset_growth_left(size_t capacity) {
+        growth_left() = CapacityToGrowth(capacity) - size_;
+    }
+
+    // Sets the control byte, and if `i < Group::kWidth`, set the cloned byte at
+    // the end too.
+    void set_ctrl(size_t i, ctrl_t h) {
+        assert(i < capacity_);
+
+        if (IsFull(h)) {
+            SanitizerUnpoisonObject(slots_ + i);
+        } else {
+            SanitizerPoisonObject(slots_ + i);
+        }
+
+        ctrl_[i] = h;
+        ctrl_[((i - Group::kWidth) & capacity_) + 1 +
+              ((Group::kWidth - 1) & capacity_)] = h;
+    }
+
+    size_t& growth_left() { return settings_.template get<0>(); }
+
+    template <size_t N,
+              template <class, class, class, class> class RefSet,
+              class M, class P, class H, class E, class A>
+    friend class parallel_hash_set;
+
+    template <size_t N,
+              template <class, class, class, class> class RefSet,
+              class M, class P, class H, class E, class A>
+    friend class parallel_hash_map;
+
+    // The representation of the object has two modes:
+    //  - small: For capacities < kWidth-1
+    //  - large: For the rest.
+    //
+    // Differences:
+    //  - In small mode we are able to use the whole capacity. The extra control
+    //  bytes give us at least one "empty" control byte to stop the iteration.
+    //  This is important to make 1 a valid capacity.
+    //
+    //  - In small mode only the first `capacity()` control bytes after the
+    //  sentinel are valid. The rest contain dummy kEmpty values that do not
+    //  represent a real slot. This is important to take into account on
+    //  find_first_non_full(), where we never try ShouldInsertBackwards() for
+    //  small tables.
+    bool is_small() const { return capacity_ < Group::kWidth - 1; }
+
+    hasher& hash_ref() { return settings_.template get<1>(); }
+    const hasher& hash_ref() const { return settings_.template get<1>(); }
+    key_equal& eq_ref() { return settings_.template get<2>(); }
+    const key_equal& eq_ref() const { return settings_.template get<2>(); }
+    allocator_type& alloc_ref() { return settings_.template get<3>(); }
+    const allocator_type& alloc_ref() const {
+        return settings_.template get<3>();
+    }
+
+    // TODO(alkis): Investigate removing some of these fields:
+    // - ctrl/slots can be derived from each other
+    // - size can be moved into the slot array
+    ctrl_t* ctrl_ = EmptyGroup();    // [(capacity + 1) * ctrl_t]
+    slot_type* slots_ = nullptr;     // [capacity * slot_type]
+    size_t size_ = 0;                // number of full slots
+    size_t capacity_ = 0;            // total number of slots
+    HashtablezInfoHandle infoz_;
+    phmap::priv::CompressedTuple<size_t /* growth_left */, hasher,
+                                              key_equal, allocator_type>
+    settings_{0, hasher{}, key_equal{}, allocator_type{}};
+};
+
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> 
+{
+    // P is Policy. It's passed as a template argument to support maps that have
+    // incomplete types as values, as in unordered_map<K, IncompleteType>.
+    // MappedReference<> may be a non-reference type.
+    template <class P>
+    using MappedReference = decltype(P::value(
+               std::addressof(std::declval<typename raw_hash_map::reference>())));
+
+    // MappedConstReference<> may be a non-reference type.
+    template <class P>
+    using MappedConstReference = decltype(P::value(
+               std::addressof(std::declval<typename raw_hash_map::const_reference>())));
+
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    using Base = raw_hash_set<Policy, Hash, Eq, Alloc>;
+
+public:
+    using key_type = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+    static_assert(!std::is_reference<key_type>::value, "");
+
+    // TODO(b/187807849): Evaluate whether to support reference mapped_type and
+    // remove this assertion if/when it is supported.
+     static_assert(!std::is_reference<mapped_type>::value, "");
+
+    using iterator = typename raw_hash_map::raw_hash_set::iterator;
+    using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
+
+    raw_hash_map() {}
+    using Base::raw_hash_set; // use raw_hash_set constructor  
+
+    // The last two template parameters ensure that both arguments are rvalues
+    // (lvalue arguments are handled by the overloads below). This is necessary
+    // for supporting bitfield arguments.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_map<int, int> m;
+    //   m.insert_or_assign(n, n);
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
+        return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
+        return insert_or_assign_impl(std::forward<K>(k), v);
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
+        return insert_or_assign_impl(k, std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
+        return insert_or_assign_impl(k, v);
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
+        return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
+        return insert_or_assign(std::forward<K>(k), v).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
+        return insert_or_assign(k, std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
+        return insert_or_assign(k, v).first;
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+              K* = nullptr>
+    std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
+        return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+    std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
+        return try_emplace_impl(k, std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args, K* = nullptr>
+    iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
+        return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class... Args>
+    iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
+        return try_emplace(k, std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> at(const key_arg<K>& key) {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedConstReference<P> at(const key_arg<K>& key) const {
+        auto it = this->find(key);
+        if (it == this->end())
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy, K* = nullptr>
+    MappedReference<P> operator[](key_arg<K>&& key) {
+        return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> operator[](const key_arg<K>& key) {
+        return Policy::value(&*try_emplace(key).first);
+    }
+
+private:
+    template <class K, class V>
+    std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
+        auto res = this->find_or_prepare_insert(k);
+        if (res.second)
+            this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
+        else
+            Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
+        return {this->iterator_at(res.first), res.second};
+    }
+
+    template <class K = key_type, class... Args>
+    std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
+        auto res = this->find_or_prepare_insert(k);
+        if (res.second)
+            this->emplace_at(res.first, std::piecewise_construct,
+                             std::forward_as_tuple(std::forward<K>(k)),
+                             std::forward_as_tuple(std::forward<Args>(args)...));
+        return {this->iterator_at(res.first), res.second};
+    }
+};
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// Returns "random" seed.
+inline size_t RandomSeed() 
+{
+#if PHMAP_HAVE_THREAD_LOCAL
+    static thread_local size_t counter = 0;
+    size_t value = ++counter;
+#else   // PHMAP_HAVE_THREAD_LOCAL
+    static std::atomic<size_t> counter(0);
+    size_t value = counter.fetch_add(1, std::memory_order_relaxed);
+#endif  // PHMAP_HAVE_THREAD_LOCAL
+    return value ^ static_cast<size_t>(reinterpret_cast<uintptr_t>(&counter));
+}
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+class parallel_hash_set 
+{
+    using PolicyTraits = hash_policy_traits<Policy>;
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    static_assert(N <= 12, "N = 12 means 4096 hash tables!");
+    constexpr static size_t num_tables = 1 << N;
+    constexpr static size_t mask = num_tables - 1;
+
+public:
+    using EmbeddedSet     = RefSet<Policy, Hash, Eq, Alloc>;
+    using EmbeddedIterator= typename EmbeddedSet::iterator;
+    using EmbeddedConstIterator= typename EmbeddedSet::const_iterator;
+    using constructor     = typename EmbeddedSet::constructor;
+    using init_type       = typename PolicyTraits::init_type;
+    using key_type        = typename PolicyTraits::key_type;
+    using slot_type       = typename PolicyTraits::slot_type;
+    using allocator_type  = Alloc;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using hasher          = Hash;
+    using key_equal       = Eq;
+    using policy_type     = Policy;
+    using value_type      = typename PolicyTraits::value_type;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using pointer         = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::pointer;
+    using const_pointer   = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+    // Alias used for heterogeneous lookup functions.
+    // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+    // `key_type` otherwise. It permits template argument deduction on `K` for the
+    // transparent case.
+    // --------------------------------------------------------------------
+    template <class K>
+    using key_arg         = typename KeyArgImpl::template type<K, key_type>;
+
+protected:
+    using Lockable = phmap::LockableImpl<Mtx_>;
+
+    // --------------------------------------------------------------------
+    struct Inner : public Lockable
+    {
+        struct Params
+        {
+            size_t bucket_cnt;
+            const hasher& hashfn;
+            const key_equal& eq;
+            const allocator_type& alloc;
+        };
+
+        Inner() {}
+
+        Inner(Params const &p) : set_(p.bucket_cnt, p.hashfn, p.eq, p.alloc)
+        {}
+
+        bool operator==(const Inner& o) const
+        {
+            typename Lockable::SharedLocks l(const_cast<Inner &>(*this), const_cast<Inner &>(o));
+            return set_ == o.set_;
+        }
+
+        EmbeddedSet set_;
+    };
+
+private:
+    // Give an early error when key_type is not hashable/eq.
+    // --------------------------------------------------------------------
+    auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+    auto KeyTypeCanBeEq(const Eq& eq, const key_type& k)      -> decltype(eq(k, k));
+
+    using AllocTraits     = phmap::allocator_traits<allocator_type>;
+
+    static_assert(std::is_lvalue_reference<reference>::value,
+                  "Policy::element() must return a reference");
+
+    template <typename T>
+    struct SameAsElementReference : std::is_same<
+        typename std::remove_cv<typename std::remove_reference<reference>::type>::type,
+        typename std::remove_cv<typename std::remove_reference<T>::type>::type> {};
+
+    // An enabler for insert(T&&): T must be convertible to init_type or be the
+    // same as [cv] value_type [ref].
+    // Note: we separate SameAsElementReference into its own type to avoid using
+    // reference unless we need to. MSVC doesn't seem to like it in some
+    // cases.
+    // --------------------------------------------------------------------
+    template <class T>
+    using RequiresInsertable = typename std::enable_if<
+        phmap::disjunction<std::is_convertible<T, init_type>,
+                          SameAsElementReference<T>>::value,
+        int>::type;
+
+    // RequiresNotInit is a workaround for gcc prior to 7.1.
+    // See https://godbolt.org/g/Y4xsUh.
+    template <class T>
+    using RequiresNotInit =
+        typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+    template <class... Ts>
+    using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+public:
+    static_assert(std::is_same<pointer, value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+    static_assert(std::is_same<const_pointer, const value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+
+    // --------------------- i t e r a t o r ------------------------------
+    class iterator 
+    {
+        friend class parallel_hash_set;
+
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type        = typename parallel_hash_set::value_type;
+        using reference         =
+            phmap::conditional_t<PolicyTraits::constant_iterators::value,
+                                const value_type&, value_type&>;
+        using pointer           = phmap::remove_reference_t<reference>*;
+        using difference_type   = typename parallel_hash_set::difference_type;
+        using Inner             = typename parallel_hash_set::Inner;
+        using EmbeddedSet       = typename parallel_hash_set::EmbeddedSet;
+        using EmbeddedIterator  = typename EmbeddedSet::iterator;
+
+        iterator() {}
+
+        reference operator*()  const { return *it_; }
+        pointer   operator->() const { return &operator*(); }
+
+        iterator& operator++() {
+            assert(inner_); // null inner means we are already at the end
+            ++it_;
+            skip_empty();
+            return *this;
+        }
+    
+        iterator operator++(int) {
+            assert(inner_);  // null inner means we are already at the end
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+        friend bool operator==(const iterator& a, const iterator& b) {
+            return a.inner_ == b.inner_ && (!a.inner_ || a.it_ == b.it_);
+        }
+
+        friend bool operator!=(const iterator& a, const iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        iterator(Inner *inner, Inner *inner_end, const EmbeddedIterator& it) : 
+            inner_(inner), inner_end_(inner_end), it_(it)  {  // for begin() and end()
+            if (inner)
+                it_end_ = inner->set_.end();
+        }
+
+        void skip_empty() {
+            while (it_ == it_end_) {
+                ++inner_;
+                if (inner_ == inner_end_) {
+                    inner_ = nullptr; // marks end()
+                    break;
+                }
+                else {
+                    it_ = inner_->set_.begin();
+                    it_end_ = inner_->set_.end();
+                }
+            }
+        }
+
+        Inner *inner_      = nullptr;
+        Inner *inner_end_  = nullptr;
+        EmbeddedIterator it_, it_end_;
+    };
+
+    // --------------------- c o n s t   i t e r a t o r -----------------
+    class const_iterator 
+    {
+        friend class parallel_hash_set;
+
+    public:
+        using iterator_category = typename iterator::iterator_category;
+        using value_type        = typename parallel_hash_set::value_type;
+        using reference         = typename parallel_hash_set::const_reference;
+        using pointer           = typename parallel_hash_set::const_pointer;
+        using difference_type   = typename parallel_hash_set::difference_type;
+        using Inner             = typename parallel_hash_set::Inner;
+
+        const_iterator() {}
+        // Implicit construction from iterator.
+        const_iterator(iterator i) : iter_(std::move(i)) {}
+
+        reference operator*()  const { return *(iter_); }
+        pointer   operator->() const { return iter_.operator->(); }
+
+        const_iterator& operator++() {
+            ++iter_;
+            return *this;
+        }
+        const_iterator operator++(int) { return iter_++; }
+
+        friend bool operator==(const const_iterator& a, const const_iterator& b) {
+            return a.iter_ == b.iter_;
+        }
+        friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        const_iterator(const Inner *inner, const Inner *inner_end, const EmbeddedIterator& it)
+            : iter_(const_cast<Inner**>(inner), 
+                    const_cast<Inner**>(inner_end),
+                    const_cast<EmbeddedIterator*>(it)) {}
+
+        iterator iter_;
+    };
+
+    using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+    using insert_return_type = InsertReturnType<iterator, node_type>;
+
+    // ------------------------- c o n s t r u c t o r s ------------------
+
+    parallel_hash_set() noexcept(
+        std::is_nothrow_default_constructible<hasher>::value&&
+        std::is_nothrow_default_constructible<key_equal>::value&&
+        std::is_nothrow_default_constructible<allocator_type>::value) {}
+
+#if  (__cplusplus >= 201703L || _MSVC_LANG >= 201402) && (defined(_MSC_VER) || defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 6))
+    explicit parallel_hash_set(size_t bucket_cnt, 
+                               const hasher& hash_param    = hasher(),
+                               const key_equal& eq         = key_equal(),
+                               const allocator_type& alloc = allocator_type()) :
+        parallel_hash_set(typename Inner::Params{bucket_cnt, hash_param, eq, alloc}, 
+                          phmap::make_index_sequence<num_tables>{})
+    {}
+
+    template <std::size_t... i>
+    parallel_hash_set(typename Inner::Params const &p,
+                      phmap::index_sequence<i...>) : sets_{((void)i, p)...}
+    {}
+#else
+    explicit parallel_hash_set(size_t bucket_cnt, 
+                               const hasher& hash_param    = hasher(),
+                               const key_equal& eq         = key_equal(),
+                               const allocator_type& alloc = allocator_type()) {
+        for (auto& inner : sets_)
+            inner.set_ = EmbeddedSet(bucket_cnt / N, hash_param, eq, alloc);
+    }
+#endif
+
+    parallel_hash_set(size_t bucket_cnt, 
+                      const hasher& hash_param,
+                      const allocator_type& alloc)
+        : parallel_hash_set(bucket_cnt, hash_param, key_equal(), alloc) {}
+
+    parallel_hash_set(size_t bucket_cnt, const allocator_type& alloc)
+        : parallel_hash_set(bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    explicit parallel_hash_set(const allocator_type& alloc)
+        : parallel_hash_set(0, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_cnt = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(bucket_cnt, hash_param, eq, alloc) {
+        insert(first, last);
+    }
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_cnt,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(first, last, bucket_cnt, hash_param, key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_cnt,
+                      const allocator_type& alloc)
+        : parallel_hash_set(first, last, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
+        : parallel_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
+
+    // Instead of accepting std::initializer_list<value_type> as the first
+    // argument like std::unordered_set<value_type> does, we have two overloads
+    // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+    // This is advantageous for performance.
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then copies
+    //   // the strings into the set.
+    //   std::unordered_set<std::string> s = {"abc", "def"};
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+    //   // copies the strings into the set.
+    //   phmap::flat_hash_set<std::string> s = {"abc", "def"};
+    //
+    // The same trick is used in insert().
+    //
+    // The enabler is necessary to prevent this constructor from triggering where
+    // the copy constructor is meant to be called.
+    //
+    //   phmap::flat_hash_set<int> a, b{a};
+    //
+    // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+    // --------------------------------------------------------------------
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_cnt = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(init.begin(), init.end(), bucket_cnt, hash_param, eq, alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(init.begin(), init.end(), bucket_cnt, hash_param, eq, alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_cnt,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_cnt, hash_param, key_equal(), alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_cnt, hash_param, key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_cnt,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_cnt,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_cnt, hasher(), key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
+        : parallel_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+  
+    parallel_hash_set(std::initializer_list<init_type> init,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    parallel_hash_set(const parallel_hash_set& that)
+        : parallel_hash_set(that, AllocTraits::select_on_container_copy_construction(
+                                that.alloc_ref())) {}
+
+    parallel_hash_set(const parallel_hash_set& that, const allocator_type& a)
+        : parallel_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = { that.sets_[i].set_, a };
+    }
+  
+    parallel_hash_set(parallel_hash_set&& that) noexcept(
+        std::is_nothrow_copy_constructible<hasher>::value&&
+        std::is_nothrow_copy_constructible<key_equal>::value&&
+        std::is_nothrow_copy_constructible<allocator_type>::value)
+        : parallel_hash_set(std::move(that), that.alloc_ref()) {
+    }
+
+    parallel_hash_set(parallel_hash_set&& that, const allocator_type& a)
+    {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = { std::move(that.sets_[i]).set_, a };
+    }
+
+    parallel_hash_set& operator=(const parallel_hash_set& that) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = that.sets_[i].set_;
+        return *this;
+    }
+
+    parallel_hash_set& operator=(parallel_hash_set&& that) noexcept(
+        phmap::allocator_traits<allocator_type>::is_always_equal::value &&
+        std::is_nothrow_move_assignable<hasher>::value &&
+        std::is_nothrow_move_assignable<key_equal>::value) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = std::move(that.sets_[i].set_);
+        return *this;
+    }
+
+    ~parallel_hash_set() {}
+
+    iterator begin() {
+        auto it = iterator(&sets_[0], &sets_[0] + num_tables, sets_[0].set_.begin());
+        it.skip_empty();
+        return it;
+    }
+
+    iterator       end()          { return iterator(); }
+    const_iterator begin()  const { return const_cast<parallel_hash_set *>(this)->begin(); }
+    const_iterator end()    const { return const_cast<parallel_hash_set *>(this)->end(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend()   const { return end(); }
+
+    bool empty() const { return !size(); }
+
+    size_t size() const { 
+        size_t sz = 0;
+        for (const auto& inner : sets_)
+            sz += inner.set_.size();
+        return sz; 
+    }
+  
+    size_t capacity() const { 
+        size_t c = 0;
+        for (const auto& inner : sets_)
+            c += inner.set_.capacity();
+        return c; 
+    }
+
+    size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
+
+    PHMAP_ATTRIBUTE_REINITIALIZES void clear() {
+        for (auto& inner : sets_)
+        {
+            typename Lockable::UniqueLock m(inner);
+            inner.set_.clear();
+        }
+    }
+
+    // extension - clears only soecified submap
+    // ----------------------------------------
+    void clear(std::size_t submap_index) {
+        Inner& inner = sets_[submap_index];
+        typename Lockable::UniqueLock m(inner);
+        inner.set_.clear();
+    }
+
+    // This overload kicks in when the argument is an rvalue of insertable and
+    // decomposable type other than init_type.
+    //
+    //   flat_hash_map<std::string, int> m;
+    //   m.insert(std::make_pair("abc", 42));
+    // --------------------------------------------------------------------
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    std::pair<iterator, bool> insert(T&& value) {
+        return emplace(std::forward<T>(value));
+    }
+
+    // This overload kicks in when the argument is a bitfield or an lvalue of
+    // insertable and decomposable type.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_set<int> s;
+    //   s.insert(n);
+    //
+    //   flat_hash_set<std::string> s;
+    //   const char* p = "hello";
+    //   s.insert(p);
+    //
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    // --------------------------------------------------------------------
+    template <
+        class T, RequiresInsertable<T> = 0,
+        typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    std::pair<iterator, bool> insert(const T& value) {
+        return emplace(value);
+    }
+
+    // This overload kicks in when the argument is an rvalue of init_type. Its
+    // purpose is to handle brace-init-list arguments.
+    //
+    //   flat_hash_set<std::pair<std::string, int>> s;
+    //   s.insert({"abc", 42});
+    // --------------------------------------------------------------------
+    std::pair<iterator, bool> insert(init_type&& value) {
+        return emplace(std::move(value));
+    }
+
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    iterator insert(const_iterator, T&& value) {
+        return insert(std::forward<T>(value)).first;
+    }
+
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    // --------------------------------------------------------------------
+    template <
+        class T, RequiresInsertable<T> = 0,
+        typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    iterator insert(const_iterator, const T& value) {
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, init_type&& value) {
+        return insert(std::move(value)).first;
+    }
+
+    template <class InputIt>
+    void insert(InputIt first, InputIt last) {
+        for (; first != last; ++first) insert(*first);
+    }
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+    void insert(std::initializer_list<T> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    void insert(std::initializer_list<init_type> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    insert_return_type insert(node_type&& node) {
+        if (!node) 
+            return {end(), false, node_type()};
+        auto& key      = node.key();
+        size_t hashval = this->hash(key);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+
+        typename Lockable::UniqueLock m(inner);
+        auto   res  = set.insert(std::move(node), hashval);
+        return { make_iterator(&inner, res.position),
+                res.inserted,
+                res.inserted ? node_type() : std::move(res.node) };
+    }
+
+    iterator insert(const_iterator, node_type&& node) {
+        return insert(std::move(node)).first;
+    }
+
+    struct ReturnKey_ 
+    {
+        template <class Key, class... Args>
+        Key operator()(Key&& k, const Args&...) const {
+            return std::forward<Key>(k);
+        }
+    };
+
+    // --------------------------------------------------------------------
+    // phmap extension: emplace_with_hash
+    // ----------------------------------
+    // same as emplace, but hashval is provided
+    // --------------------------------------------------------------------
+    template <class K, class... Args>
+    std::pair<iterator, bool> emplace_decomposable_with_hash(const K& key, size_t hashval, Args&&... args)
+    {
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_rv(&inner, set.emplace_decomposable(key, hashval, std::forward<Args>(args)...));
+    }
+
+    struct EmplaceDecomposableHashval 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable_with_hash(key, hashval, std::forward<Args>(args)...);
+        }
+        parallel_hash_set& s;
+        size_t hashval;
+    };
+
+    // This overload kicks in if we can deduce the key from args. This enables us
+    // to avoid constructing value_type if an entry with the same key already
+    // exists.
+    //
+    // For example:
+    //
+    //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+    //   // Creates no std::string copies and makes no heap allocations.
+    //   m.emplace("abc", "xyz");
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace_with_hash(size_t hashval, Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposableHashval{*this, hashval},
+                                   std::forward<Args>(args)...);
+    }
+
+    // This overload kicks in if we cannot deduce the key from args. It constructs
+    // value_type unconditionally and then either moves it into the table or
+    // destroys.
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 !IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace_with_hash(size_t hashval, Args&&... args) {
+        typename phmap::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        Inner& inner    = sets_[subidx(hashval)];
+        auto&  set      = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        typename EmbeddedSet::template InsertSlotWithHash<true> f {
+            inner, std::move(*slot), hashval};
+        return make_rv(PolicyTraits::apply(f, elem));
+    }
+
+    template <class... Args>
+    iterator emplace_hint_with_hash(size_t hashval, const_iterator, Args&&... args) {
+        return emplace_with_hash(hashval, std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace_with_hash(const key_arg<K>& key, size_t hashval, F&& f) {
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_iterator(&inner, set.lazy_emplace_with_hash(key, hashval, std::forward<F>(f)));
+    }
+
+    // --------------------------------------------------------------------
+    // end of phmap expension
+    // --------------------------------------------------------------------
+
+    template <class K, class... Args>
+    std::pair<iterator, bool> emplace_decomposable(const K& key, Args&&... args)
+    {
+        size_t hashval = this->hash(key);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_rv(&inner, set.emplace_decomposable(key, hashval, std::forward<Args>(args)...));
+    }
+
+    struct EmplaceDecomposable 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable(key, std::forward<Args>(args)...);
+        }
+        parallel_hash_set& s;
+    };
+
+    // This overload kicks in if we can deduce the key from args. This enables us
+    // to avoid constructing value_type if an entry with the same key already
+    // exists.
+    //
+    // For example:
+    //
+    //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+    //   // Creates no std::string copies and makes no heap allocations.
+    //   m.emplace("abc", "xyz");
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposable{*this},
+                                   std::forward<Args>(args)...);
+    }
+
+    // This overload kicks in if we cannot deduce the key from args. It constructs
+    // value_type unconditionally and then either moves it into the table or
+    // destroys.
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 !IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        typename phmap::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+        size_t hashval  = this->hash(PolicyTraits::key(slot));
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        Inner& inner    = sets_[subidx(hashval)];
+        auto&  set      = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        typename EmbeddedSet::template InsertSlotWithHash<true> f {
+            inner, std::move(*slot), hashval};
+        return make_rv(PolicyTraits::apply(f, elem));
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    iterator make_iterator(Inner* inner, const EmbeddedIterator it)
+    {
+        if (it == inner->set_.end())
+            return iterator();
+        return iterator(inner, &sets_[0] + num_tables, it);
+    }
+
+    std::pair<iterator, bool> make_rv(Inner* inner, 
+                                      const std::pair<EmbeddedIterator, bool>& res)
+    {
+        return {iterator(inner, &sets_[0] + num_tables, res.first), res.second};
+    }
+
+    // lazy_emplace
+    // ------------
+    template <class K = key_type, class F>
+    iterator lazy_emplace(const key_arg<K>& key, F&& f) {
+        auto hashval = this->hash(key);
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_iterator(&inner, set.lazy_emplace_with_hash(key, hashval, std::forward<F>(f)));
+    }
+    
+    // emplace_single
+    // --------------
+    template <class K = key_type, class F>
+    void emplace_single_with_hash(const key_arg<K>& key, size_t hashval, F&& f) {
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        set.emplace_single_with_hash(key, hashval, std::forward<F>(f));
+    }
+
+    template <class K = key_type, class F>
+    void emplace_single(const key_arg<K>& key, F&& f) {
+        auto hashval = this->hash(key);
+        emplace_single_with_hash<K, F>(key, hashval, std::forward<F>(f));
+    }
+
+    // if set contains key, lambda is called with the value_type (under read lock protection),
+    // and if_contains returns true. This is a const API and lambda should not modify the value
+    // -----------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool if_contains(const key_arg<K>& key, F&& f) const {
+        return const_cast<parallel_hash_set*>(this)->template 
+            modify_if_impl<K, F, typename Lockable::SharedLock>(key, std::forward<F>(f));
+    }
+
+    // if set contains key, lambda is called with the value_type  without read lock protection,
+    // and if_contains_unsafe returns true. This is a const API and lambda should not modify the value
+    // This should be used only if we know that no other thread may be mutating the set at the time.
+    // -----------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool if_contains_unsafe(const key_arg<K>& key, F&& f) const {
+        return const_cast<parallel_hash_set*>(this)->template 
+            modify_if_impl<K, F, LockableBaseImpl<phmap::NullMutex>::DoNothing>(key, std::forward<F>(f));
+    }
+
+    // if map contains key, lambda is called with the value_type  (under write lock protection),
+    // and modify_if returns true. This is a non-const API and lambda is allowed to modify the mapped value
+    // ----------------------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool modify_if(const key_arg<K>& key, F&& f) {
+        return modify_if_impl<K, F, typename Lockable::UniqueLock>(key, std::forward<F>(f));
+    }
+
+    // -----------------------------------------------------------------------------------------
+    template <class K = key_type, class F, class L>
+    bool modify_if_impl(const key_arg<K>& key, F&& f) {
+#if __cplusplus >= 201703L
+        static_assert(std::is_invocable<F, value_type&>::value);
+#endif
+        L m;
+        auto ptr = this->template find_ptr<K, L>(key, this->hash(key), m);
+        if (ptr == nullptr)
+            return false;
+        std::forward<F>(f)(*ptr);
+        return true;
+    }
+
+    // if map contains key, lambda is called with the mapped value  (under write lock protection).
+    // If the lambda returns true, the key is subsequently erased from the map (the write lock
+    // is only released after erase).
+    // returns true if key was erased, false otherwise.
+    // ----------------------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool erase_if(const key_arg<K>& key, F&& f) {
+        return erase_if_impl<K, F, typename Lockable::UniqueLock>(key, std::forward<F>(f));
+    }
+
+    template <class K = key_type, class F, class L>
+    bool erase_if_impl(const key_arg<K>& key, F&& f) {
+#if __cplusplus >= 201703L
+        static_assert(std::is_invocable<F, value_type&>::value);
+#endif
+        L m;
+        auto it = this->template find<K, L>(key, this->hash(key), m);
+        if (it == this->end()) return false;
+        if (std::forward<F>(f)(const_cast<value_type &>(*it)))
+        {
+            this->erase(it);
+            return true;
+        }
+        return false;
+    }
+
+    // if map already  contains key, the first lambda is called with the mapped value (under 
+    // write lock protection) and can update the mapped value.
+    // if map does not contains key, the second lambda is called and it should invoke the 
+    // passed constructor to construct the value
+    // returns true if key was not already present, false otherwise.
+    // ---------------------------------------------------------------------------------------
+    template <class K = key_type, class FExists, class FEmplace>
+    bool lazy_emplace_l(const key_arg<K>& key, FExists&& fExists, FEmplace&& fEmplace) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(key, m);
+        Inner* inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.lazy_emplace_at(std::get<1>(res), std::forward<FEmplace>(fEmplace));
+        else {
+            auto it = this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res)));
+            std::forward<FExists>(fExists)(const_cast<value_type &>(*it)); // in case of the set, non "key" part of value_type can be changed
+        }
+        return std::get<2>(res);
+    }
+
+    // Extension API: support iterating over all values
+    //
+    // flat_hash_set<std::string> s;
+    // s.insert(...);
+    // s.for_each([](auto const & key) {
+    //    // Safely iterates over all the keys
+    // });
+    template <class F>
+    void for_each(F&& fCallback) const {
+        for (auto const& inner : sets_) {
+            typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+            std::for_each(inner.set_.begin(), inner.set_.end(), fCallback);
+        }
+    }
+
+    // this version allows to modify the values
+    template <class F>
+    void for_each_m(F&& fCallback) {
+        for (auto& inner : sets_) {
+            typename Lockable::UniqueLock m(inner);
+            std::for_each(inner.set_.begin(), inner.set_.end(), fCallback);
+        }
+    }
+
+#if __cplusplus >= 201703L
+    template <class ExecutionPolicy, class F>
+    void for_each(ExecutionPolicy&& policy, F&& fCallback) const {
+        std::for_each(
+            std::forward<ExecutionPolicy>(policy), sets_.begin(), sets_.end(),
+            [&](auto const& inner) {
+                typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+                std::for_each(inner.set_.begin(), inner.set_.end(), fCallback);
+            }
+        );
+    }
+
+    template <class ExecutionPolicy, class F>
+    void for_each_m(ExecutionPolicy&& policy, F&& fCallback) {
+        std::for_each(
+            std::forward<ExecutionPolicy>(policy), sets_.begin(), sets_.end(),
+            [&](auto& inner) {
+                typename Lockable::UniqueLock m(inner);
+                std::for_each(inner.set_.begin(), inner.set_.end(), fCallback);
+            }
+        );
+    }
+#endif
+
+    // Extension API: access internal submaps by index
+    // under lock protection
+    // ex: m.with_submap(i, [&](const Map::EmbeddedSet& set) {
+    //        for (auto& p : set) { ...; }});
+    // -------------------------------------------------
+    template <class F>
+    void with_submap(size_t idx, F&& fCallback) const {
+        const Inner& inner     = sets_[idx];
+        const auto&  set = inner.set_;
+        typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+        fCallback(set);
+    }
+
+    template <class F>
+    void with_submap_m(size_t idx, F&& fCallback) {
+        Inner& inner   = sets_[idx];
+        auto&  set     = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        fCallback(set);
+    }
+
+    // unsafe, for internal use only
+    Inner& get_inner(size_t idx) {
+        return  sets_[idx];
+    }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.erase("abc");
+    //
+    //   flat_hash_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.erase("abc");
+    //
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    size_type erase(const key_arg<K>& key) {
+        auto hashval = this->hash(key);
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UpgradeLock m(inner);
+        auto it   = set.find(key, hashval);
+        if (it == set.end()) 
+            return 0;
+
+        typename Lockable::UpgradeToUnique unique(m);
+        set._erase(it);
+        return 1;
+    }
+
+    // --------------------------------------------------------------------
+    iterator erase(const_iterator cit) { return erase(cit.iter_); }
+
+    // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+    // this method returns void to reduce algorithmic complexity to O(1).  In
+    // order to erase while iterating across a map, use the following idiom (which
+    // also works for standard containers):
+    //
+    // for (auto it = m.begin(), end = m.end(); it != end;) {
+    //   if (<pred>) {
+    //     m._erase(it++);
+    //   } else {
+    //     ++it;
+    //   }
+    // }
+    //
+    // Do not use erase APIs taking iterators when accessing the map concurrently
+    // --------------------------------------------------------------------
+    void _erase(iterator it) {
+        Inner* inner = it.inner_;
+        assert(inner != nullptr);
+        auto&  set   = inner->set_;
+        // typename Lockable::UniqueLock m(*inner); // don't lock here 
+        
+        set._erase(it.it_);
+    }
+    void _erase(const_iterator cit) { _erase(cit.iter_); }
+
+    // This overload is necessary because otherwise erase<K>(const K&) would be
+    // a better match if non-const iterator is passed as an argument.
+    // Do not use erase APIs taking iterators when accessing the map concurrently
+    // --------------------------------------------------------------------
+    iterator erase(iterator it) { _erase(it++); return it; }
+
+    iterator erase(const_iterator first, const_iterator last) {
+        while (first != last) {
+            _erase(first++);
+        }
+        return last.iter_;
+    }
+
+    // Moves elements from `src` into `this`.
+    // If the element already exists in `this`, it is left unmodified in `src`.
+    // Do not use erase APIs taking iterators when accessing the map concurrently
+    // --------------------------------------------------------------------
+    template <typename E = Eq>
+    void merge(parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, E, Alloc>& src) {  // NOLINT
+        assert(this != &src);
+        if (this != &src)
+        {
+            for (size_t i=0; i<num_tables; ++i)
+            {
+                typename Lockable::UniqueLocks l(sets_[i], src.sets_[i]);
+                sets_[i].set_.merge(src.sets_[i].set_);
+            }
+        }
+    }
+
+    template <typename E = Eq>
+    void merge(parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, E, Alloc>&& src) {
+        merge(src);
+    }
+
+    node_type extract(const_iterator position) {
+        return position.iter_.inner_->set_.extract(EmbeddedConstIterator(position.iter_.it_));
+    }
+
+    template <
+        class K = key_type,
+        typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+    node_type extract(const key_arg<K>& key) {
+        auto it = find(key);
+        return it == end() ? node_type() : extract(const_iterator{it});
+    }
+
+    template<class Mtx2_>
+    void swap(parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc>& that)
+        noexcept(IsNoThrowSwappable<EmbeddedSet>() &&
+                 (!AllocTraits::propagate_on_container_swap::value ||
+                  IsNoThrowSwappable<allocator_type>()))
+    {
+        using std::swap;
+        using Lockable2 = phmap::LockableImpl<Mtx2_>;
+         
+        for (size_t i=0; i<num_tables; ++i)
+        {
+            typename Lockable::UniqueLock l(sets_[i]);
+            typename Lockable2::UniqueLock l2(that.get_inner(i));
+            swap(sets_[i].set_, that.get_inner(i).set_);
+        }
+    }
+
+    void rehash(size_t n) {
+        size_t nn = n / num_tables;
+        for (auto& inner : sets_)
+        {
+            typename Lockable::UniqueLock m(inner);
+            inner.set_.rehash(nn);
+        }
+    }
+
+    void reserve(size_t n) 
+    {
+        size_t target = GrowthToLowerboundCapacity(n);
+        size_t normalized = 16 * NormalizeCapacity(n / num_tables);
+        rehash(normalized > target ? normalized : target); 
+    }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.count("abc");
+    //
+    //   ch_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.count("abc");
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    size_t count(const key_arg<K>& key) const {
+        return find(key) == end() ? 0 : 1;
+    }
+
+    // Issues CPU prefetch instructions for the memory needed to find or insert
+    // a key.  Like all lookup functions, this support heterogeneous keys.
+    //
+    // NOTE: This is a very low level operation and should not be used without
+    // specific benchmarks indicating its importance.
+    // --------------------------------------------------------------------
+    void prefetch_hash(size_t hashval) const {
+        const Inner& inner = sets_[subidx(hashval)];
+        const auto&  set   = inner.set_;
+        typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+        set.prefetch_hash(hashval);
+    }
+
+    template <class K = key_type>
+    void prefetch(const key_arg<K>& key) const {
+        prefetch_hash(this->hash(key));
+    }
+
+    // The API of find() has two extensions.
+    //
+    // 1. The hash can be passed by the user. It must be equal to the hash of the
+    // key.
+    //
+    // 2. The type of the key argument doesn't have to be key_type. This is so
+    // called heterogeneous key support.
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key, size_t hashval) {
+        typename Lockable::SharedLock m;
+        return find(key, hashval, m);
+    }
+
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key) {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key, size_t hashval) const {
+        return const_cast<parallel_hash_set*>(this)->find(key, hashval);
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key) const {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key) const {
+        return find(key) != end();
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key, size_t hashval) const {
+        return find(key, hashval) != end();
+    }
+
+    template <class K = key_type>
+    std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    template <class K = key_type>
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_arg<K>& key) const {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    size_t bucket_count() const {
+        size_t sz = 0;
+        for (const auto& inner : sets_)
+        {
+            typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+            sz += inner.set_.bucket_count();
+        }
+        return sz; 
+    }
+
+    float load_factor() const {
+        size_t _capacity = bucket_count();
+        return _capacity ? static_cast<float>(static_cast<double>(size()) / _capacity) : 0;
+    }
+
+    float max_load_factor() const { return 1.0f; }
+    void max_load_factor(float) {
+        // Does nothing.
+    }
+
+    hasher hash_function() const { return hash_ref(); }  // warning: doesn't match internal hash - use hash() member function
+    key_equal key_eq() const { return eq_ref(); }
+    allocator_type get_allocator() const { return alloc_ref(); }
+
+    friend bool operator==(const parallel_hash_set& a, const parallel_hash_set& b) {
+        return std::equal(a.sets_.begin(), a.sets_.end(), b.sets_.begin());
+    }
+
+    friend bool operator!=(const parallel_hash_set& a, const parallel_hash_set& b) {
+        return !(a == b);
+    }
+
+    template<class Mtx2_>
+    friend void swap(parallel_hash_set& a,
+                     parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc>& b)
+        noexcept(noexcept(a.swap(b)))
+    {
+        a.swap(b);
+    }
+
+    template <class K>
+    size_t hash(const K& key) const {
+        return HashElement{hash_ref()}(key);
+    }
+
+#if !defined(PHMAP_NON_DETERMINISTIC)
+    template<typename OutputArchive>
+    bool phmap_dump(OutputArchive& ar) const;
+
+    template<typename InputArchive>
+    bool phmap_load(InputArchive& ar);
+#endif
+
+private:
+    template <class Container, typename Enabler>
+    friend struct phmap::priv::hashtable_debug_internal::HashtableDebugAccess;
+
+    struct FindElement 
+    {
+        template <class K, class... Args>
+        const_iterator operator()(const K& key, Args&&...) const {
+            return s.find(key);
+        }
+        const parallel_hash_set& s;
+    };
+
+    struct HashElement 
+    {
+        template <class K, class... Args>
+        size_t operator()(const K& key, Args&&...) const {
+            return phmap_mix<sizeof(size_t)>()(h(key));
+        }
+        const hasher& h;
+    };
+
+    template <class K1>
+    struct EqualElement 
+    {
+        template <class K2, class... Args>
+        bool operator()(const K2& lhs, Args&&...) const {
+            return eq(lhs, rhs);
+        }
+        const K1& rhs;
+        const key_equal& eq;
+    };
+
+    // "erases" the object from the container, except that it doesn't actually
+    // destroy the object. It only updates all the metadata of the class.
+    // This can be used in conjunction with Policy::transfer to move the object to
+    // another place.
+    // --------------------------------------------------------------------
+    void erase_meta_only(const_iterator cit) {
+        auto &it = cit.iter_;
+        assert(it.set_ != nullptr);
+        it.set_.erase_meta_only(const_iterator(it.it_));
+    }
+
+    void drop_deletes_without_resize() PHMAP_ATTRIBUTE_NOINLINE {
+        for (auto& inner : sets_)
+        {
+            typename Lockable::UniqueLock m(inner);
+            inner.set_.drop_deletes_without_resize();
+        }
+    }
+
+    bool has_element(const value_type& elem) const {
+        size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+        typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+        return set.has_element(elem, hashval);
+    }
+
+    // TODO(alkis): Optimize this assuming *this and that don't overlap.
+    // --------------------------------------------------------------------
+    template<class Mtx2_>
+    parallel_hash_set& move_assign(parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc>&& that, std::true_type) {
+        parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc> tmp(std::move(that));
+        swap(tmp);
+        return *this;
+    }
+
+    template<class Mtx2_>
+    parallel_hash_set& move_assign(parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc>&& that, std::false_type) {
+        parallel_hash_set<N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc> tmp(std::move(that), alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+protected:
+    template <class K = key_type, class L = typename Lockable::SharedLock>
+    pointer find_ptr(const key_arg<K>& key, size_t hashval, L& mutexlock)
+    {
+        Inner& inner = sets_[subidx(hashval)];
+        auto& set = inner.set_;
+        mutexlock = std::move(L(inner));
+        return set.find_ptr(key, hashval);
+    }
+
+    template <class K = key_type, class L = typename Lockable::SharedLock>
+    iterator find(const key_arg<K>& key, size_t hashval, L& mutexlock) {
+        Inner& inner = sets_[subidx(hashval)];
+        auto& set = inner.set_;
+        mutexlock = std::move(L(inner));
+        return make_iterator(&inner, set.find(key, hashval));
+    }
+
+    template <class K>
+    std::tuple<Inner*, size_t, bool> 
+    find_or_prepare_insert_with_hash(size_t hashval, const K& key, typename Lockable::UniqueLock &mutexlock) {
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        mutexlock    = std::move(typename Lockable::UniqueLock(inner));
+        auto  p   = set.find_or_prepare_insert(key, hashval); // std::pair<size_t, bool>
+        return std::make_tuple(&inner, p.first, p.second);
+    }
+
+    template <class K>
+    std::tuple<Inner*, size_t, bool> 
+    find_or_prepare_insert(const K& key, typename Lockable::UniqueLock &mutexlock) {
+        return find_or_prepare_insert_with_hash<K>(this->hash(key), key, mutexlock);
+    }
+
+    iterator iterator_at(Inner *inner, 
+                         const EmbeddedIterator& it) { 
+        return {inner, &sets_[0] + num_tables, it}; 
+    }
+    const_iterator iterator_at(Inner *inner, 
+                               const EmbeddedIterator& it) const { 
+        return {inner, &sets_[0] + num_tables, it}; 
+    }
+
+    static size_t subidx(size_t hashval) {
+        return ((hashval >> 8) ^ (hashval >> 16) ^ (hashval >> 24)) & mask;
+    }
+
+    static size_t subcnt() {
+        return num_tables;
+    }
+
+private:
+    friend struct RawHashSetTestOnlyAccess;
+
+    size_t growth_left() { 
+        size_t sz = 0;
+        for (const auto& set : sets_)
+            sz += set.growth_left();
+        return sz; 
+    }
+
+    hasher&       hash_ref()        { return sets_[0].set_.hash_ref(); }
+    const hasher& hash_ref() const  { return sets_[0].set_.hash_ref(); }
+    key_equal&       eq_ref()       { return sets_[0].set_.eq_ref(); }
+    const key_equal& eq_ref() const { return sets_[0].set_.eq_ref(); }
+    allocator_type&  alloc_ref()    { return sets_[0].set_.alloc_ref(); }
+    const allocator_type& alloc_ref() const { 
+        return sets_[0].set_.alloc_ref();
+    }
+
+protected:       // protected in case users want to derive fromm this
+    std::array<Inner, num_tables> sets_;
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+class parallel_hash_map : public parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc> 
+{
+    // P is Policy. It's passed as a template argument to support maps that have
+    // incomplete types as values, as in unordered_map<K, IncompleteType>.
+    // MappedReference<> may be a non-reference type.
+    template <class P>
+    using MappedReference = decltype(P::value(
+            std::addressof(std::declval<typename parallel_hash_map::reference>())));
+
+    // MappedConstReference<> may be a non-reference type.
+    template <class P>
+    using MappedConstReference = decltype(P::value(
+            std::addressof(std::declval<typename parallel_hash_map::const_reference>())));
+
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    using Base = typename parallel_hash_map::parallel_hash_set;
+    using Lockable = phmap::LockableImpl<Mtx_>;
+
+public:
+    using key_type    = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+    using value_type  = typename Base::value_type;
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+    static_assert(!std::is_reference<key_type>::value, "");
+    // TODO(alkis): remove this assertion and verify that reference mapped_type is
+    // supported.
+    static_assert(!std::is_reference<mapped_type>::value, "");
+
+    using iterator = typename parallel_hash_map::parallel_hash_set::iterator;
+    using const_iterator = typename parallel_hash_map::parallel_hash_set::const_iterator;
+
+    parallel_hash_map() {}
+
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using parallel_hash_map::parallel_hash_set::parallel_hash_set;
+#endif
+
+    // The last two template parameters ensure that both arguments are rvalues
+    // (lvalue arguments are handled by the overloads below). This is necessary
+    // for supporting bitfield arguments.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_map<int, int> m;
+    //   m.insert_or_assign(n, n);
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
+        return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
+        return insert_or_assign_impl(std::forward<K>(k), v);
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
+        return insert_or_assign_impl(k, std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
+        return insert_or_assign_impl(k, v);
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
+        return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
+        return insert_or_assign(std::forward<K>(k), v).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
+        return insert_or_assign(k, std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
+        return insert_or_assign(k, v).first;
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+              K* = nullptr>
+    std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
+        return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+    std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
+        return try_emplace_impl(k, std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args, K* = nullptr>
+    iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
+        return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class... Args>
+    iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
+        return try_emplace(k, std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> at(const key_arg<K>& key) {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedConstReference<P> at(const key_arg<K>& key) const {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    // ----------- phmap extensions --------------------------
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+              K* = nullptr>
+    std::pair<iterator, bool> try_emplace_with_hash(size_t hashval, key_arg<K>&& k, Args&&... args) {
+        return try_emplace_impl_with_hash(hashval, std::forward<K>(k), std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+    std::pair<iterator, bool> try_emplace_with_hash(size_t hashval, const key_arg<K>& k, Args&&... args) {
+        return try_emplace_impl_with_hash(hashval, k, std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args, K* = nullptr>
+    iterator try_emplace_with_hash(size_t hashval, const_iterator, key_arg<K>&& k, Args&&... args) {
+        return try_emplace_with_hash(hashval, std::forward<K>(k), std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class... Args>
+    iterator try_emplace_with_hash(size_t hashval, const_iterator, const key_arg<K>& k, Args&&... args) {
+        return try_emplace_with_hash(hashval, k, std::forward<Args>(args)...).first;
+    }
+
+    // if map does not contains key, it is inserted and the mapped value is value-constructed 
+    // with the provided arguments (if any), as with try_emplace. 
+    // if map already  contains key, then the lambda is called with the mapped value (under 
+    // write lock protection) and can update the mapped value.
+    // returns true if key was not already present, false otherwise.
+    // ---------------------------------------------------------------------------------------
+    template <class K = key_type, class F, class... Args>
+    bool try_emplace_l(K&& k, F&& f, Args&&... args) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::piecewise_construct,
+                                   std::forward_as_tuple(std::forward<K>(k)),
+                                   std::forward_as_tuple(std::forward<Args>(args)...));
+        else {
+            auto it = this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res)));
+            std::forward<F>(f)(const_cast<value_type &>(*it)); // in case of the set, non "key" part of value_type can be changed
+        }
+        return std::get<2>(res);
+    }
+
+    // ----------- end of phmap extensions --------------------------
+
+    template <class K = key_type, class P = Policy, K* = nullptr>
+    MappedReference<P> operator[](key_arg<K>&& key) {
+        return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> operator[](const key_arg<K>& key) {
+        return Policy::value(&*try_emplace(key).first);
+    }
+
+private:
+
+    template <class K, class V>
+    std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::forward<K>(k), std::forward<V>(v));
+        else
+            Policy::value(&*inner->set_.iterator_at(std::get<1>(res))) = std::forward<V>(v);
+        return {this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res))), 
+                std::get<2>(res)};
+    }
+
+    template <class K = key_type, class... Args>
+    std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::piecewise_construct,
+                                   std::forward_as_tuple(std::forward<K>(k)),
+                                   std::forward_as_tuple(std::forward<Args>(args)...));
+        return {this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res))), 
+                std::get<2>(res)};
+    }
+
+    template <class K = key_type, class... Args>
+    std::pair<iterator, bool> try_emplace_impl_with_hash(size_t hashval, K&& k, Args&&... args) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert_with_hash(hashval, k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::piecewise_construct,
+                                   std::forward_as_tuple(std::forward<K>(k)),
+                                   std::forward_as_tuple(std::forward<Args>(args)...));
+        return {this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res))), 
+                std::get<2>(res)};
+    }
+
+    
+};
+
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+// ----------------------------------------------------------------------------
+template <class Alloc, class T, class Tuple>
+void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) {
+    memory_internal::ConstructFromTupleImpl(
+        alloc, ptr, std::forward<Tuple>(t),
+        phmap::make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>());
+}
+
+// Constructs T using the args specified in the tuple and calls F with the
+// constructed value.
+// ----------------------------------------------------------------------------
+template <class T, class Tuple, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructed(
+    Tuple&& t, F&& f) {
+    return memory_internal::WithConstructedImpl<T>(
+        std::forward<Tuple>(t),
+        phmap::make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>(),
+        std::forward<F>(f));
+}
+
+// ----------------------------------------------------------------------------
+// Given arguments of an std::pair's consructor, PairArgs() returns a pair of
+// tuples with references to the passed arguments. The tuples contain
+// constructor arguments for the first and the second elements of the pair.
+//
+// The following two snippets are equivalent.
+//
+// 1. std::pair<F, S> p(args...);
+//
+// 2. auto a = PairArgs(args...);
+//    std::pair<F, S> p(std::piecewise_construct,
+//                      std::move(p.first), std::move(p.second));
+// ----------------------------------------------------------------------------
+inline std::pair<std::tuple<>, std::tuple<>> PairArgs() { return {}; }
+
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
+  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
+          std::forward_as_tuple(std::forward<S>(s))};
+}
+
+template <class F, class S>
+std::pair<std::tuple<const F&>, std::tuple<const S&>> PairArgs(
+    const std::pair<F, S>& p) {
+    return PairArgs(p.first, p.second);
+}
+
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
+    return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
+}
+
+template <class F, class S>
+auto PairArgs(std::piecewise_construct_t, F&& f, S&& s)
+    -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                               memory_internal::TupleRef(std::forward<S>(s)))) {
+    return std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                          memory_internal::TupleRef(std::forward<S>(s)));
+}
+
+// A helper function for implementing apply() in map policies.
+// ----------------------------------------------------------------------------
+template <class F, class... Args>
+auto DecomposePair(F&& f, Args&&... args)
+    -> decltype(memory_internal::DecomposePairImpl(
+        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
+    return memory_internal::DecomposePairImpl(
+        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
+}
+
+// A helper function for implementing apply() in set policies.
+// ----------------------------------------------------------------------------
+template <class F, class Arg>
+decltype(std::declval<F>()(std::declval<const Arg&>(), std::declval<Arg>()))
+DecomposeValue(F&& f, Arg&& arg) {
+    const auto& key = arg;
+    return std::forward<F>(f)(key, std::forward<Arg>(arg));
+}
+
+
+// --------------------------------------------------------------------------
+// Policy: a policy defines how to perform different operations on
+// the slots of the hashtable (see hash_policy_traits.h for the full interface
+// of policy).
+//
+// Hash: a (possibly polymorphic) functor that hashes keys of the hashtable. The
+// functor should accept a key and return size_t as hash. For best performance
+// it is important that the hash function provides high entropy across all bits
+// of the hash.
+//
+// Eq: a (possibly polymorphic) functor that compares two keys for equality. It
+// should accept two (of possibly different type) keys and return a bool: true
+// if they are equal, false if they are not. If two keys compare equal, then
+// their hash values as defined by Hash MUST be equal.
+//
+// Allocator: an Allocator [https://devdocs.io/cpp/concept/allocator] with which
+// the storage of the hashtable will be allocated and the elements will be
+// constructed and destroyed.
+// --------------------------------------------------------------------------
+template <class T>
+struct FlatHashSetPolicy 
+{
+    using slot_type = T;
+    using key_type = T;
+    using init_type = T;
+    using constant_iterators = std::true_type;
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        phmap::allocator_traits<Allocator>::construct(*alloc, slot,
+                                                      std::forward<Args>(args)...);
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        phmap::allocator_traits<Allocator>::destroy(*alloc, slot);
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        construct(alloc, new_slot, std::move(*old_slot));
+        destroy(alloc, old_slot);
+    }
+
+    static T& element(slot_type* slot) { return *slot; }
+
+    template <class F, class... Args>
+    static decltype(phmap::priv::DecomposeValue(
+                        std::declval<F>(), std::declval<Args>()...))
+    apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposeValue(
+            std::forward<F>(f), std::forward<Args>(args)...);
+    }
+
+    static size_t space_used(const T*) { return 0; }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class K, class V>
+struct FlatHashMapPolicy 
+{
+    using slot_policy = priv::map_slot_policy<K, V>;
+    using slot_type = typename slot_policy::slot_type;
+    using key_type = K;
+    using mapped_type = V;
+    using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        slot_policy::destroy(alloc, slot);
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        slot_policy::transfer(alloc, new_slot, old_slot);
+    }
+
+    template <class F, class... Args>
+    static decltype(phmap::priv::DecomposePair(
+                        std::declval<F>(), std::declval<Args>()...))
+    apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposePair(std::forward<F>(f),
+                                                        std::forward<Args>(args)...);
+    }
+
+    static size_t space_used(const slot_type*) { return 0; }
+
+    static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
+
+    static V& value(std::pair<const K, V>* kv) { return kv->second; }
+    static const V& value(const std::pair<const K, V>* kv) { return kv->second; }
+};
+
+template <class Reference, class Policy>
+struct node_hash_policy {
+    static_assert(std::is_lvalue_reference<Reference>::value, "");
+
+    using slot_type = typename std::remove_cv<
+        typename std::remove_reference<Reference>::type>::type*;
+
+    template <class Alloc, class... Args>
+    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+        *slot = Policy::new_element(alloc, std::forward<Args>(args)...);
+    }
+
+    template <class Alloc>
+    static void destroy(Alloc* alloc, slot_type* slot) {
+        Policy::delete_element(alloc, *slot);
+    }
+
+    template <class Alloc>
+    static void transfer(Alloc*, slot_type* new_slot, slot_type* old_slot) {
+        *new_slot = *old_slot;
+    }
+
+    static size_t space_used(const slot_type* slot) {
+        if (slot == nullptr) return Policy::element_space_used(nullptr);
+        return Policy::element_space_used(*slot);
+    }
+
+    static Reference element(slot_type* slot) { return **slot; }
+
+    template <class T, class P = Policy>
+    static auto value(T* elem) -> decltype(P::value(elem)) {
+        return P::value(elem);
+    }
+
+    template <class... Ts, class P = Policy>
+    static auto apply(Ts&&... ts) -> decltype(P::apply(std::forward<Ts>(ts)...)) {
+        return P::apply(std::forward<Ts>(ts)...);
+    }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class T>
+struct NodeHashSetPolicy
+    : phmap::priv::node_hash_policy<T&, NodeHashSetPolicy<T>> 
+{
+    using key_type = T;
+    using init_type = T;
+    using constant_iterators = std::true_type;
+
+    template <class Allocator, class... Args>
+        static T* new_element(Allocator* alloc, Args&&... args) {
+        using ValueAlloc =
+            typename phmap::allocator_traits<Allocator>::template rebind_alloc<T>;
+        ValueAlloc value_alloc(*alloc);
+        T* res = phmap::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
+        phmap::allocator_traits<ValueAlloc>::construct(value_alloc, res,
+                                                       std::forward<Args>(args)...);
+        return res;
+    }
+
+    template <class Allocator>
+        static void delete_element(Allocator* alloc, T* elem) {
+        using ValueAlloc =
+            typename phmap::allocator_traits<Allocator>::template rebind_alloc<T>;
+        ValueAlloc value_alloc(*alloc);
+        phmap::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
+        phmap::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
+    }
+
+    template <class F, class... Args>
+        static decltype(phmap::priv::DecomposeValue(
+                            std::declval<F>(), std::declval<Args>()...))
+        apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposeValue(
+            std::forward<F>(f), std::forward<Args>(args)...);
+    }
+
+    static size_t element_space_used(const T*) { return sizeof(T); }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class Key, class Value>
+class NodeHashMapPolicy
+    : public phmap::priv::node_hash_policy<
+          std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>> 
+{
+    using value_type = std::pair<const Key, Value>;
+
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+    template <class Allocator, class... Args>
+        static value_type* new_element(Allocator* alloc, Args&&... args) {
+        using PairAlloc = typename phmap::allocator_traits<
+            Allocator>::template rebind_alloc<value_type>;
+        PairAlloc pair_alloc(*alloc);
+        value_type* res =
+            phmap::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
+        phmap::allocator_traits<PairAlloc>::construct(pair_alloc, res,
+                                                      std::forward<Args>(args)...);
+        return res;
+    }
+
+    template <class Allocator>
+        static void delete_element(Allocator* alloc, value_type* pair) {
+        using PairAlloc = typename phmap::allocator_traits<
+            Allocator>::template rebind_alloc<value_type>;
+        PairAlloc pair_alloc(*alloc);
+        phmap::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
+        phmap::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
+    }
+
+    template <class F, class... Args>
+        static decltype(phmap::priv::DecomposePair(
+                            std::declval<F>(), std::declval<Args>()...))
+        apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposePair(std::forward<F>(f),
+                                                        std::forward<Args>(args)...);
+    }
+
+    static size_t element_space_used(const value_type*) {
+        return sizeof(value_type);
+    }
+
+    static Value& value(value_type* elem) { return elem->second; }
+    static const Value& value(const value_type* elem) { return elem->second; }
+};
+
+
+// --------------------------------------------------------------------------
+//  hash_default
+// --------------------------------------------------------------------------
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+
+// Supports heterogeneous lookup for basic_string<T>-like elements.
+template<class CharT> 
+struct StringHashEqT
+{
+    struct Hash 
+    {
+        using is_transparent = void;
+        
+        size_t operator()(std::basic_string_view<CharT> v) const {
+            std::string_view bv{
+                reinterpret_cast<const char*>(v.data()), v.size() * sizeof(CharT)};
+            return std::hash<std::string_view>()(bv);
+        }
+    };
+
+    struct Eq {
+        using is_transparent = void;
+
+        bool operator()(std::basic_string_view<CharT> lhs,
+                        std::basic_string_view<CharT> rhs) const {
+            return lhs == rhs;
+        }
+    };
+};
+
+template <>
+struct HashEq<std::string> : StringHashEqT<char> {};
+
+template <>
+struct HashEq<std::string_view> : StringHashEqT<char> {};
+
+// char16_t
+template <>
+struct HashEq<std::u16string> : StringHashEqT<char16_t> {};
+
+template <>
+struct HashEq<std::u16string_view> : StringHashEqT<char16_t> {};
+
+// wchar_t
+template <>
+struct HashEq<std::wstring> : StringHashEqT<wchar_t> {};
+
+template <>
+struct HashEq<std::wstring_view> : StringHashEqT<wchar_t> {};
+
+#endif
+
+// Supports heterogeneous lookup for pointers and smart pointers.
+// -------------------------------------------------------------
+template <class T>
+struct HashEq<T*> 
+{
+    struct Hash {
+        using is_transparent = void;
+        template <class U>
+        size_t operator()(const U& ptr) const {
+            // we want phmap::Hash<T*> and not phmap::Hash<const T*>
+            // so "struct std::hash<T*> " override works
+            return phmap::Hash<T*>{}((T*)(uintptr_t)HashEq::ToPtr(ptr));
+        }
+    };
+
+    struct Eq {
+        using is_transparent = void;
+        template <class A, class B>
+        bool operator()(const A& a, const B& b) const {
+            return HashEq::ToPtr(a) == HashEq::ToPtr(b);
+        }
+    };
+
+private:
+    static const T* ToPtr(const T* ptr) { return ptr; }
+
+    template <class U, class D>
+    static const T* ToPtr(const std::unique_ptr<U, D>& ptr) {
+        return ptr.get();
+    }
+
+    template <class U>
+    static const T* ToPtr(const std::shared_ptr<U>& ptr) {
+        return ptr.get();
+    }
+};
+
+template <class T, class D>
+struct HashEq<std::unique_ptr<T, D>> : HashEq<T*> {};
+
+template <class T>
+struct HashEq<std::shared_ptr<T>> : HashEq<T*> {};
+
+namespace hashtable_debug_internal {
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+
+template<typename, typename = void >
+struct has_member_type_raw_hash_set : std::false_type
+{};
+template<typename T>
+struct has_member_type_raw_hash_set<T, phmap::void_t<typename T::raw_hash_set>> : std::true_type
+{};
+
+template <typename Set>
+struct HashtableDebugAccess<Set, typename std::enable_if<has_member_type_raw_hash_set<Set>::value>::type>
+{
+    using Traits = typename Set::PolicyTraits;
+    using Slot = typename Traits::slot_type;
+
+    static size_t GetNumProbes(const Set& set,
+                               const typename Set::key_type& key) {
+        size_t num_probes = 0;
+        size_t hashval = set.hash(key); 
+        auto seq = set.probe(hashval);
+        while (true) {
+            priv::Group g{set.ctrl_ + seq.offset()};
+            for (uint32_t i : g.Match(priv::H2(hashval))) {
+                if (Traits::apply(
+                        typename Set::template EqualElement<typename Set::key_type>{
+                            key, set.eq_ref()},
+                        Traits::element(set.slots_ + seq.offset((size_t)i))))
+                    return num_probes;
+                ++num_probes;
+            }
+            if (g.MatchEmpty()) return num_probes;
+            seq.next();
+            ++num_probes;
+        }
+    }
+
+    static size_t AllocatedByteSize(const Set& c) {
+        size_t capacity = c.capacity_;
+        if (capacity == 0) return 0;
+        auto layout = Set::MakeLayout(capacity);
+        size_t m = layout.AllocSize();
+
+        size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+        if (per_slot != ~size_t{}) {
+            m += per_slot * c.size();
+        } else {
+            for (size_t i = 0; i != capacity; ++i) {
+                if (priv::IsFull(c.ctrl_[i])) {
+                    m += Traits::space_used(c.slots_ + i);
+                }
+            }
+        }
+        return m;
+    }
+
+    static size_t LowerBoundAllocatedByteSize(size_t size) {
+        size_t capacity = GrowthToLowerboundCapacity(size);
+        if (capacity == 0) return 0;
+        auto layout = Set::MakeLayout(NormalizeCapacity(capacity));
+        size_t m = layout.AllocSize();
+        size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+        if (per_slot != ~size_t{}) {
+            m += per_slot * size;
+        }
+        return m;
+    }
+};
+
+
+template<typename, typename = void >
+struct has_member_type_EmbeddedSet : std::false_type
+{};
+template<typename T>
+struct has_member_type_EmbeddedSet<T, phmap::void_t<typename T::EmbeddedSet>> : std::true_type
+{};
+
+template <typename Set>
+struct HashtableDebugAccess<Set, typename std::enable_if<has_member_type_EmbeddedSet<Set>::value>::type> {
+    using Traits = typename Set::PolicyTraits;
+    using Slot = typename Traits::slot_type;
+    using EmbeddedSet = typename Set::EmbeddedSet;
+
+    static size_t GetNumProbes(const Set& set, const typename Set::key_type& key) {
+        size_t hashval = set.hash(key);
+        auto& inner = set.sets_[set.subidx(hashval)];
+        auto& inner_set = inner.set_;
+        return HashtableDebugAccess<EmbeddedSet>::GetNumProbes(inner_set, key);
+    }
+};
+
+}  // namespace hashtable_debug_internal
+}  // namespace priv
+
+// -----------------------------------------------------------------------------
+// phmap::flat_hash_set
+// -----------------------------------------------------------------------------
+// An `phmap::flat_hash_set<T>` is an unordered associative container which has
+// been optimized for both speed and memory footprint in most common use cases.
+// Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the set is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `_erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class flat_hash_set
+    : public phmap::priv::raw_hash_set<
+          phmap::priv::FlatHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename flat_hash_set::raw_hash_set;
+
+public:
+    flat_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear; // may shrink - To avoid shrinking `erase(begin(), end())`
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint; 
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::flat_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `phmap::flat_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `_erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class K, class V, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class flat_hash_map : public phmap::priv::raw_hash_map<
+                          phmap::priv::FlatHashMapPolicy<K, V>,
+                          Hash, Eq, Alloc> {
+    using Base = typename flat_hash_map::raw_hash_map;
+
+public:
+    flat_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::node_hash_set
+// -----------------------------------------------------------------------------
+// An `phmap::node_hash_set<T>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class node_hash_set
+    : public phmap::priv::raw_hash_set<
+          phmap::priv::NodeHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename node_hash_set::raw_hash_set;
+
+public:
+    node_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::emplace_with_hash;
+    using Base::emplace_hint_with_hash;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::node_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `phmap::node_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class Key, class Value, class Hash, class Eq, class Alloc>  // default values in phmap_fwd_decl.h
+class node_hash_map
+    : public phmap::priv::raw_hash_map<
+          phmap::priv::NodeHashMapPolicy<Key, Value>, Hash, Eq,
+          Alloc> 
+{
+    using Base = typename node_hash_map::raw_hash_map;
+
+public:
+    node_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_flat_hash_set
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_> // default values in phmap_fwd_decl.h
+class parallel_flat_hash_set
+    : public phmap::priv::parallel_hash_set<
+         N, phmap::priv::raw_hash_set, Mtx_,
+         phmap::priv::FlatHashSetPolicy<T>, 
+         Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_flat_hash_set::parallel_hash_set;
+
+public:
+    parallel_flat_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::emplace_with_hash;
+    using Base::emplace_hint_with_hash;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_flat_hash_map - default values in phmap_fwd_decl.h
+// -----------------------------------------------------------------------------
+template <class K, class V, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_flat_hash_map : public phmap::priv::parallel_hash_map<
+                N, phmap::priv::raw_hash_set, Mtx_,
+                phmap::priv::FlatHashMapPolicy<K, V>,
+                Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_flat_hash_map::parallel_hash_map;
+
+public:
+    parallel_flat_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::emplace_with_hash;
+    using Base::emplace_hint_with_hash;
+    using Base::try_emplace_with_hash;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_node_hash_set
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_node_hash_set
+    : public phmap::priv::parallel_hash_set<
+             N, phmap::priv::raw_hash_set, Mtx_,
+             phmap::priv::NodeHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_node_hash_set::parallel_hash_set;
+
+public:
+    parallel_node_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::emplace_with_hash;
+    using Base::emplace_hint_with_hash;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_node_hash_map
+// -----------------------------------------------------------------------------
+template <class Key, class Value, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_node_hash_map
+    : public phmap::priv::parallel_hash_map<
+          N, phmap::priv::raw_hash_set, Mtx_,
+          phmap::priv::NodeHashMapPolicy<Key, Value>, Hash, Eq,
+          Alloc> 
+{
+    using Base = typename parallel_node_hash_map::parallel_hash_map;
+
+public:
+    parallel_node_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::emplace_with_hash;
+    using Base::emplace_hint_with_hash;
+    using Base::try_emplace_with_hash;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+}  // namespace phmap
+
+
+namespace phmap {
+    namespace priv {
+        template <class C, class Pred> 
+        std::size_t erase_if(C &c, Pred pred) {
+            auto old_size = c.size();
+            for (auto i = c.begin(), last = c.end(); i != last; ) {
+                if (pred(*i)) {
+                    i = c.erase(i);
+                } else {
+                    ++i;
+                }
+            }
+            return old_size - c.size();
+        }
+    } // priv
+
+    // ======== erase_if for phmap set containers ==================================
+    template <class T, class Hash, class Eq, class Alloc, class Pred> 
+    std::size_t erase_if(phmap::flat_hash_set<T, Hash, Eq, Alloc>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class T, class Hash, class Eq, class Alloc, class Pred> 
+    std::size_t erase_if(phmap::node_hash_set<T, Hash, Eq, Alloc>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_, class Pred> 
+    std::size_t erase_if(phmap::parallel_flat_hash_set<T, Hash, Eq, Alloc, N, Mtx_>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_, class Pred> 
+    std::size_t erase_if(phmap::parallel_node_hash_set<T, Hash, Eq, Alloc, N, Mtx_>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    // ======== erase_if for phmap map containers ==================================
+    template <class K, class V, class Hash, class Eq, class Alloc, class Pred> 
+    std::size_t erase_if(phmap::flat_hash_map<K, V, Hash, Eq, Alloc>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class K, class V, class Hash, class Eq, class Alloc, class Pred> 
+    std::size_t erase_if(phmap::node_hash_map<K, V, Hash, Eq, Alloc>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class K, class V, class Hash, class Eq, class Alloc, size_t N, class Mtx_, class Pred> 
+    std::size_t erase_if(phmap::parallel_flat_hash_map<K, V, Hash, Eq, Alloc, N, Mtx_>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+    template <class K, class V, class Hash, class Eq, class Alloc, size_t N, class Mtx_, class Pred> 
+    std::size_t erase_if(phmap::parallel_node_hash_map<K, V, Hash, Eq, Alloc, N, Mtx_>& c, Pred pred) {
+        return phmap::priv::erase_if(c, std::move(pred));
+    }
+
+} // phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif // phmap_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_base.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_base.h
new file mode 100644
index 00000000..0cb89310
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_base.h
@@ -0,0 +1,5157 @@
+#if !defined(phmap_base_h_guard_)
+#define phmap_base_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <functional>
+#include <tuple>
+#include <utility>
+#include <memory>
+#include <mutex> // for std::lock
+
+#include "phmap_config.h"
+
+#ifdef PHMAP_HAVE_SHARED_MUTEX
+    #include <shared_mutex>  // after "phmap_config.h"
+#endif
+
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4582) // constructor is not implicitly called
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) //  selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+#endif  // _MSC_VER
+
+namespace phmap {
+
+template <class T> using Allocator = typename std::allocator<T>;
+
+template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
+
+template <class T>
+struct EqualTo
+{
+    inline bool operator()(const T& a, const T& b) const
+    {
+        return std::equal_to<T>()(a, b);
+    }
+};
+
+template <class T>
+struct Less
+{
+    inline bool operator()(const T& a, const T& b) const
+    {
+        return std::less<T>()(a, b);
+    }
+};
+
+namespace type_traits_internal {
+
+template <typename... Ts>
+struct VoidTImpl {
+  using type = void;
+};
+
+// NOTE: The `is_detected` family of templates here differ from the library
+// fundamentals specification in that for library fundamentals, `Op<Args...>` is
+// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
+// substitution, regardless of whether or not the `::value` is accessed. That
+// is inconsistent with all other standard traits and prevents lazy evaluation
+// in larger contexts (such as if the `is_detected` check is a trailing argument
+// of a `conjunction`. This implementation opts to instead be lazy in the same
+// way that the standard traits are (this "defect" of the detection idiom
+// specifications has been reported).
+// ---------------------------------------------------------------------------
+
+template <class Enabler, template <class...> class Op, class... Args>
+struct is_detected_impl {
+  using type = std::false_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected : is_detected_impl<void, Op, Args...>::type {};
+
+template <class Enabler, class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl {
+  using type = std::false_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl<
+    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
+    To, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible
+    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
+
+template <typename T>
+using IsCopyAssignableImpl =
+    decltype(std::declval<T&>() = std::declval<const T&>());
+
+template <typename T>
+using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
+
+}  // namespace type_traits_internal
+
+template <typename T>
+struct is_copy_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsCopyAssignableImpl, T> {
+};
+
+template <typename T>
+struct is_move_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsMoveAssignableImpl, T> {
+};
+
+// ---------------------------------------------------------------------------
+// void_t()
+//
+// Ignores the type of any its arguments and returns `void`. In general, this
+// metafunction allows you to create a general case that maps to `void` while
+// allowing specializations that map to specific types.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::void_t` metafunction.
+//
+// NOTE: `phmap::void_t` does not use the standard-specified implementation so
+// that it can remain compatible with gcc < 5.1. This can introduce slightly
+// different behavior, such as when ordering partial specializations.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+// ---------------------------------------------------------------------------
+// conjunction
+//
+// Performs a compile-time logical AND operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `false` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::conjunction` metafunction.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+struct conjunction;
+
+template <typename T, typename... Ts>
+struct conjunction<T, Ts...>
+    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
+
+template <typename T>
+struct conjunction<T> : T {};
+
+template <>
+struct conjunction<> : std::true_type {};
+
+// ---------------------------------------------------------------------------
+// disjunction
+//
+// Performs a compile-time logical OR operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `true` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::disjunction` metafunction.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+struct disjunction;
+
+template <typename T, typename... Ts>
+struct disjunction<T, Ts...> :
+      std::conditional<T::value, T, disjunction<Ts...>>::type {};
+
+template <typename T>
+struct disjunction<T> : T {};
+
+template <>
+struct disjunction<> : std::false_type {};
+
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+template <typename T>
+struct is_trivially_destructible
+    : std::integral_constant<bool, __has_trivial_destructor(T) &&
+      std::is_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_default_constructible
+    : std::integral_constant<bool, __has_trivial_constructor(T) &&
+                                   std::is_default_constructible<T>::value &&
+      is_trivially_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_copy_constructible
+    : std::integral_constant<bool, __has_trivial_copy(T) &&
+                                   std::is_copy_constructible<T>::value &&
+      is_trivially_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_copy_assignable
+    : std::integral_constant<
+          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
+      phmap::is_copy_assignable<T>::value> {};
+
+// -----------------------------------------------------------------------------
+// C++14 "_t" trait aliases
+// -----------------------------------------------------------------------------
+
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
+
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+
+template <typename T>
+using remove_volatile_t = typename std::remove_volatile<T>::type;
+
+template <typename T>
+using add_cv_t = typename std::add_cv<T>::type;
+
+template <typename T>
+using add_const_t = typename std::add_const<T>::type;
+
+template <typename T>
+using add_volatile_t = typename std::add_volatile<T>::type;
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
+
+template <typename T>
+using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+
+template <typename T>
+using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+template <typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
+
+template <typename T>
+using make_signed_t = typename std::make_signed<T>::type;
+
+template <typename T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+
+template <typename T>
+using remove_extent_t = typename std::remove_extent<T>::type;
+
+template <typename T>
+using remove_all_extents_t = typename std::remove_all_extents<T>::type;
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage {
+    struct type {
+        alignas(Align) unsigned char data[Len];
+    };
+};
+
+template< std::size_t Len, std::size_t Align>
+using aligned_storage_t = typename aligned_storage<Len, Align>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+
+template <typename... T>
+using common_type_t = typename std::common_type<T...>::type;
+
+template <typename T>
+using underlying_type_t = typename std::underlying_type<T>::type;
+
+template< class F, class... ArgTypes>
+#if PHMAP_HAVE_CC17 && defined(__cpp_lib_result_of_sfinae)
+    using invoke_result_t = typename std::invoke_result_t<F, ArgTypes...>;
+#else
+    using invoke_result_t = typename std::result_of<F(ArgTypes...)>::type;
+#endif
+
+namespace type_traits_internal {
+
+// ----------------------------------------------------------------------
+// In MSVC we can't probe std::hash or stdext::hash because it triggers a
+// static_assert instead of failing substitution. Libc++ prior to 4.0
+// also used a static_assert.
+// ----------------------------------------------------------------------
+#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
+                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
+    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
+#else
+    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
+#endif
+
+#if !PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+    template <typename Key, typename = size_t>
+    struct IsHashable : std::true_type {};
+#else   // PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+    template <typename Key, typename = void>
+    struct IsHashable : std::false_type {};
+
+    template <typename Key>
+    struct IsHashable<Key,
+        phmap::enable_if_t<std::is_convertible<
+            decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
+            std::size_t>::value>> : std::true_type {};
+#endif
+
+struct AssertHashEnabledHelper 
+{
+private:
+    static void Sink(...) {}
+    struct NAT {};
+
+    template <class Key>
+    static auto GetReturnType(int)
+        -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
+    template <class Key>
+    static NAT GetReturnType(...);
+
+    template <class Key>
+    static std::nullptr_t DoIt() {
+        static_assert(IsHashable<Key>::value,
+                      "std::hash<Key> does not provide a call operator");
+        static_assert(
+            std::is_default_constructible<std::hash<Key>>::value,
+            "std::hash<Key> must be default constructible when it is enabled");
+        static_assert(
+            std::is_copy_constructible<std::hash<Key>>::value,
+            "std::hash<Key> must be copy constructible when it is enabled");
+        static_assert(phmap::is_copy_assignable<std::hash<Key>>::value,
+                      "std::hash<Key> must be copy assignable when it is enabled");
+        // is_destructible is unchecked as it's implied by each of the
+        // is_constructible checks.
+        using ReturnType = decltype(GetReturnType<Key>(0));
+        static_assert(std::is_same<ReturnType, NAT>::value ||
+                      std::is_same<ReturnType, size_t>::value,
+                      "std::hash<Key> must return size_t");
+        return nullptr;
+    }
+
+    template <class... Ts>
+    friend void AssertHashEnabled();
+};
+
+template <class... Ts>
+inline void AssertHashEnabled
+() 
+{
+    using Helper = AssertHashEnabledHelper;
+    Helper::Sink(Helper::DoIt<Ts>()...);
+}
+
+}  // namespace type_traits_internal
+
+}  // namespace phmap
+
+
+// -----------------------------------------------------------------------------
+//          hash_policy_traits
+// -----------------------------------------------------------------------------
+namespace phmap {
+namespace priv {
+
+// Defines how slots are initialized/destroyed/moved.
+template <class Policy, class = void>
+struct hash_policy_traits 
+{
+private:
+    struct ReturnKey 
+    {
+        // We return `Key` here.
+        // When Key=T&, we forward the lvalue reference.
+        // When Key=T, we return by value to avoid a dangling reference.
+        // eg, for string_hash_map.
+        template <class Key, class... Args>
+        Key operator()(Key&& k, const Args&...) const {
+            return std::forward<Key>(k);
+        }
+    };
+
+    template <class P = Policy, class = void>
+    struct ConstantIteratorsImpl : std::false_type {};
+
+    template <class P>
+    struct ConstantIteratorsImpl<P, phmap::void_t<typename P::constant_iterators>>
+        : P::constant_iterators {};
+
+public:
+    // The actual object stored in the hash table.
+    using slot_type  = typename Policy::slot_type;
+
+    // The type of the keys stored in the hashtable.
+    using key_type   = typename Policy::key_type;
+
+    // The argument type for insertions into the hashtable. This is different
+    // from value_type for increased performance. See initializer_list constructor
+    // and insert() member functions for more details.
+    using init_type  = typename Policy::init_type;
+
+    using reference  = decltype(Policy::element(std::declval<slot_type*>()));
+    using pointer    = typename std::remove_reference<reference>::type*;
+    using value_type = typename std::remove_reference<reference>::type;
+
+    // Policies can set this variable to tell raw_hash_set that all iterators
+    // should be constant, even `iterator`. This is useful for set-like
+    // containers.
+    // Defaults to false if not provided by the policy.
+    using constant_iterators = ConstantIteratorsImpl<>;
+
+    // PRECONDITION: `slot` is UNINITIALIZED
+    // POSTCONDITION: `slot` is INITIALIZED
+    template <class Alloc, class... Args>
+    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+        Policy::construct(alloc, slot, std::forward<Args>(args)...);
+    }
+
+    // PRECONDITION: `slot` is INITIALIZED
+    // POSTCONDITION: `slot` is UNINITIALIZED
+    template <class Alloc>
+    static void destroy(Alloc* alloc, slot_type* slot) {
+        Policy::destroy(alloc, slot);
+    }
+
+    // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
+    // allocator inside `old_slot` to `new_slot` can be transferred.
+    //
+    // OPTIONAL: defaults to:
+    //
+    //     clone(new_slot, std::move(*old_slot));
+    //     destroy(old_slot);
+    //
+    // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
+    // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
+    //                UNINITIALIZED
+    template <class Alloc>
+    static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
+        transfer_impl(alloc, new_slot, old_slot, 0);
+    }
+
+    // PRECONDITION: `slot` is INITIALIZED
+    // POSTCONDITION: `slot` is INITIALIZED
+    template <class P = Policy>
+    static auto element(slot_type* slot) -> decltype(P::element(slot)) {
+        return P::element(slot);
+    }
+
+    // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
+    //
+    // If `slot` is nullptr, returns the constant amount of memory owned by any
+    // full slot or -1 if slots own variable amounts of memory.
+    //
+    // PRECONDITION: `slot` is INITIALIZED or nullptr
+    template <class P = Policy>
+    static size_t space_used(const slot_type* slot) {
+        return P::space_used(slot);
+    }
+
+    // Provides generalized access to the key for elements, both for elements in
+    // the table and for elements that have not yet been inserted (or even
+    // constructed).  We would like an API that allows us to say: `key(args...)`
+    // but we cannot do that for all cases, so we use this more general API that
+    // can be used for many things, including the following:
+    //
+    //   - Given an element in a table, get its key.
+    //   - Given an element initializer, get its key.
+    //   - Given `emplace()` arguments, get the element key.
+    //
+    // Implementations of this must adhere to a very strict technical
+    // specification around aliasing and consuming arguments:
+    //
+    // Let `value_type` be the result type of `element()` without ref- and
+    // cv-qualifiers. The first argument is a functor, the rest are constructor
+    // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
+    // `k` is the element key, and `xs...` are the new constructor arguments for
+    // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
+    // `ts...`. The key won't be touched once `xs...` are used to construct an
+    // element; `ts...` won't be touched at all, which allows `apply()` to consume
+    // any rvalues among them.
+    //
+    // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
+    // trigger a hard compile error unless it originates from `f`. In other words,
+    // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
+    // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
+    //
+    // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
+    // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
+    template <class F, class... Ts, class P = Policy>
+    static auto apply(F&& f, Ts&&... ts)
+        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
+        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
+    }
+
+    // Returns the "key" portion of the slot.
+    // Used for node handle manipulation.
+    template <class P = Policy>
+    static auto key(slot_type* slot)
+        -> decltype(P::apply(ReturnKey(), element(slot))) {
+        return P::apply(ReturnKey(), element(slot));
+    }
+
+    // Returns the "value" (as opposed to the "key") portion of the element. Used
+    // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
+    template <class T, class P = Policy>
+    static auto value(T* elem) -> decltype(P::value(elem)) {
+        return P::value(elem);
+    }
+
+private:
+
+    // Use auto -> decltype as an enabler.
+    template <class Alloc, class P = Policy>
+    static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
+                              slot_type* old_slot, int)
+        -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
+        P::transfer(alloc, new_slot, old_slot);
+    }
+
+    template <class Alloc>
+    static void transfer_impl(Alloc* alloc, slot_type* new_slot,
+                              slot_type* old_slot, char) {
+        construct(alloc, new_slot, std::move(element(old_slot)));
+        destroy(alloc, old_slot);
+    }
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+// file utility.h
+// -----------------------------------------------------------------------------
+
+// --------- identity.h
+namespace phmap {
+namespace internal {
+
+template <typename T>
+struct identity {
+    typedef T type;
+};
+
+template <typename T>
+using identity_t = typename identity<T>::type;
+
+}  // namespace internal
+}  // namespace phmap
+
+
+// --------- inline_variable.h
+
+#ifdef __cpp_inline_variables
+
+#if defined(__clang__)
+    #define PHMAP_INTERNAL_EXTERN_DECL(type, name) \
+      extern const ::phmap::internal::identity_t<type> name;
+#else  // Otherwise, just define the macro to do nothing.
+    #define PHMAP_INTERNAL_EXTERN_DECL(type, name)
+#endif  // defined(__clang__)
+
+// See above comment at top of file for details.
+#define PHMAP_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
+  PHMAP_INTERNAL_EXTERN_DECL(type, name)                  \
+  inline constexpr ::phmap::internal::identity_t<type> name = init
+
+#else
+
+// See above comment at top of file for details.
+//
+// Note:
+//   identity_t is used here so that the const and name are in the
+//   appropriate place for pointer types, reference types, function pointer
+//   types, etc..
+#define PHMAP_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
+  template <class /*PhmapInternalDummy*/ = void>                               \
+  struct PhmapInternalInlineVariableHolder##name {                             \
+    static constexpr ::phmap::internal::identity_t<var_type> kInstance = init; \
+  };                                                                          \
+                                                                              \
+  template <class PhmapInternalDummy>                                          \
+  constexpr ::phmap::internal::identity_t<var_type>                            \
+      PhmapInternalInlineVariableHolder##name<PhmapInternalDummy>::kInstance;   \
+                                                                              \
+  static constexpr const ::phmap::internal::identity_t<var_type>&              \
+      name = /* NOLINT */                                                     \
+      PhmapInternalInlineVariableHolder##name<>::kInstance;                    \
+  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
+                "Silence unused variable warnings.")
+
+#endif  // __cpp_inline_variables
+
+// ----------- throw_delegate
+
+namespace phmap {
+namespace base_internal {
+
+namespace {
+template <typename T>
+#ifdef PHMAP_HAVE_EXCEPTIONS
+[[noreturn]] void Throw(const T& error) {
+    throw error;
+}
+#else
+[[noreturn]] void Throw(const T&) {
+    std::abort();
+}
+#endif
+}  // namespace
+
+static inline void ThrowStdLogicError(const std::string& what_arg) {
+  Throw(std::logic_error(what_arg));
+}
+static inline void ThrowStdLogicError(const char* what_arg) {
+  Throw(std::logic_error(what_arg));
+}
+static inline void ThrowStdInvalidArgument(const std::string& what_arg) {
+  Throw(std::invalid_argument(what_arg));
+}
+static inline void ThrowStdInvalidArgument(const char* what_arg) {
+  Throw(std::invalid_argument(what_arg));
+}
+
+static inline void ThrowStdDomainError(const std::string& what_arg) {
+  Throw(std::domain_error(what_arg));
+}
+static inline void ThrowStdDomainError(const char* what_arg) {
+  Throw(std::domain_error(what_arg));
+}
+
+static inline void ThrowStdLengthError(const std::string& what_arg) {
+  Throw(std::length_error(what_arg));
+}
+static inline void ThrowStdLengthError(const char* what_arg) {
+  Throw(std::length_error(what_arg));
+}
+
+static inline void ThrowStdOutOfRange(const std::string& what_arg) {
+  Throw(std::out_of_range(what_arg));
+}
+static inline void ThrowStdOutOfRange(const char* what_arg) {
+  Throw(std::out_of_range(what_arg));
+}
+
+static inline void ThrowStdRuntimeError(const std::string& what_arg) {
+  Throw(std::runtime_error(what_arg));
+}
+static inline void ThrowStdRuntimeError(const char* what_arg) {
+  Throw(std::runtime_error(what_arg));
+}
+
+static inline void ThrowStdRangeError(const std::string& what_arg) {
+  Throw(std::range_error(what_arg));
+}
+static inline void ThrowStdRangeError(const char* what_arg) {
+  Throw(std::range_error(what_arg));
+}
+
+static inline void ThrowStdOverflowError(const std::string& what_arg) {
+  Throw(std::overflow_error(what_arg));
+}
+static inline void ThrowStdOverflowError(const char* what_arg) {
+  Throw(std::overflow_error(what_arg));
+}
+
+static inline void ThrowStdUnderflowError(const std::string& what_arg) {
+  Throw(std::underflow_error(what_arg));
+}
+static inline void ThrowStdUnderflowError(const char* what_arg) {
+  Throw(std::underflow_error(what_arg));
+}
+
+static inline void ThrowStdBadFunctionCall() { Throw(std::bad_function_call()); }
+
+static inline void ThrowStdBadAlloc() { Throw(std::bad_alloc()); }
+
+}  // namespace base_internal
+}  // namespace phmap
+
+// ----------- invoke.h
+
+namespace phmap {
+namespace base_internal {
+
+template <typename Derived>
+struct StrippedAccept 
+{
+    template <typename... Args>
+    struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
+                                                     typename std::remove_reference<Args>::type>::type...> {};
+};
+
+// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+// and t1 is an object of type T or a reference to an object of type T or a
+// reference to an object of a type derived from T.
+struct MemFunAndRef : StrippedAccept<MemFunAndRef> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename... Params, typename Obj,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...), Obj, Args...>
+        : std::is_base_of<C, Obj> {};
+
+    template <typename R, typename C, typename... Params, typename Obj,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...) const, Obj, Args...>
+        : std::is_base_of<C, Obj> {};
+
+    template <typename MemFun, typename Obj, typename... Args>
+    static decltype((std::declval<Obj>().*
+                     std::declval<MemFun>())(std::declval<Args>()...))
+    Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
+        return (std::forward<Obj>(obj).*
+                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+    }
+};
+
+// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+// class T and t1 is not one of the types described in the previous item.
+struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename... Params, typename Ptr,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...), Ptr, Args...>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename R, typename C, typename... Params, typename Ptr,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...) const, Ptr, Args...>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename MemFun, typename Ptr, typename... Args>
+    static decltype(((*std::declval<Ptr>()).*
+                     std::declval<MemFun>())(std::declval<Args>()...))
+    Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
+        return ((*std::forward<Ptr>(ptr)).*
+                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+    }
+};
+
+// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+// an object of type T or a reference to an object of type T or a reference
+// to an object of a type derived from T.
+struct DataMemAndRef : StrippedAccept<DataMemAndRef> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename Obj>
+    struct AcceptImpl<R C::*, Obj> : std::is_base_of<C, Obj> {};
+
+    template <typename DataMem, typename Ref>
+    static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
+        DataMem&& data_mem, Ref&& ref) {
+        return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
+    }
+};
+
+// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+// is not one of the types described in the previous item.
+struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename Ptr>
+    struct AcceptImpl<R C::*, Ptr>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename DataMem, typename Ptr>
+    static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
+        DataMem&& data_mem, Ptr&& ptr) {
+        return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
+    }
+};
+
+// f(t1, t2, ..., tN) in all other cases.
+struct Callable
+{
+    // Callable doesn't have Accept because it's the last clause that gets picked
+    // when none of the previous clauses are applicable.
+    template <typename F, typename... Args>
+    static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
+        F&& f, Args&&... args) {
+        return std::forward<F>(f)(std::forward<Args>(args)...);
+    }
+};
+
+// Resolves to the first matching clause.
+template <typename... Args>
+struct Invoker 
+{
+    typedef typename std::conditional<
+        MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
+        typename std::conditional<
+            MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
+            typename std::conditional<
+                DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
+                typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
+                                          DataMemAndPtr, Callable>::type>::type>::
+        type>::type type;
+};
+
+// The result type of Invoke<F, Args...>.
+template <typename F, typename... Args>
+using InvokeT = decltype(Invoker<F, Args...>::type::Invoke(
+    std::declval<F>(), std::declval<Args>()...));
+
+// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
+// [func.require] of the C++ standard.
+template <typename F, typename... Args>
+InvokeT<F, Args...> Invoke(F&& f, Args&&... args) {
+  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
+                                           std::forward<Args>(args)...);
+}
+}  // namespace base_internal
+}  // namespace phmap
+
+
+// ----------- utility.h
+
+namespace phmap {
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `phmap::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence 
+{
+    using value_type = T;
+    static constexpr size_t size() noexcept { return sizeof...(Ints); }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `phmap::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal {
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen {
+  using type =
+      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
+};
+
+template <typename T>
+struct Gen<T, 0> {
+  using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// Tag types
+
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+
+using std::in_place_t;
+using std::in_place;
+
+#else  // PHMAP_HAVE_STD_OPTIONAL
+
+// in_place_t
+//
+// Tag type used to specify in-place construction, such as with
+// `phmap::optional`, designed to be a drop-in replacement for C++17's
+// `std::in_place_t`.
+struct in_place_t {};
+
+PHMAP_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
+
+#endif  // PHMAP_HAVE_STD_OPTIONAL
+
+#if defined(PHMAP_HAVE_STD_ANY) || defined(PHMAP_HAVE_STD_VARIANT)
+using std::in_place_type_t;
+#else
+
+// in_place_type_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `phmap::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_type_t`.
+template <typename T>
+struct in_place_type_t {};
+#endif  // PHMAP_HAVE_STD_ANY || PHMAP_HAVE_STD_VARIANT
+
+#ifdef PHMAP_HAVE_STD_VARIANT
+using std::in_place_index_t;
+#else
+
+// in_place_index_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `phmap::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_index_t`.
+template <size_t I>
+struct in_place_index_t {};
+#endif  // PHMAP_HAVE_STD_VARIANT
+
+// Constexpr move and forward
+
+// move()
+//
+// A constexpr version of `std::move()`, designed to be a drop-in replacement
+// for C++14's `std::move()`.
+template <typename T>
+constexpr phmap::remove_reference_t<T>&& move(T&& t) noexcept {
+  return static_cast<phmap::remove_reference_t<T>&&>(t);
+}
+
+// forward()
+//
+// A constexpr version of `std::forward()`, designed to be a drop-in replacement
+// for C++14's `std::forward()`.
+template <typename T>
+constexpr T&& forward(
+    phmap::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
+  return static_cast<T&&>(t);
+}
+
+namespace utility_internal {
+// Helper method for expanding tuple into a called method.
+template <typename Functor, typename Tuple, std::size_t... Indexes>
+auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
+    -> decltype(phmap::base_internal::Invoke(
+        phmap::forward<Functor>(functor),
+        std::get<Indexes>(phmap::forward<Tuple>(t))...)) {
+  return phmap::base_internal::Invoke(
+      phmap::forward<Functor>(functor),
+      std::get<Indexes>(phmap::forward<Tuple>(t))...);
+}
+
+}  // namespace utility_internal
+
+// apply
+//
+// Invokes a Callable using elements of a tuple as its arguments.
+// Each element of the tuple corresponds to an argument of the call (in order).
+// Both the Callable argument and the tuple argument are perfect-forwarded.
+// For member-function Callables, the first tuple element acts as the `this`
+// pointer. `phmap::apply` is designed to be a drop-in replacement for C++17's
+// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
+//
+// Example:
+//
+//   class Foo {
+//    public:
+//     void Bar(int);
+//   };
+//   void user_function1(int, std::string);
+//   void user_function2(std::unique_ptr<Foo>);
+//   auto user_lambda = [](int, int) {};
+//
+//   int main()
+//   {
+//       std::tuple<int, std::string> tuple1(42, "bar");
+//       // Invokes the first user function on int, std::string.
+//       phmap::apply(&user_function1, tuple1);
+//
+//       std::tuple<std::unique_ptr<Foo>> tuple2(phmap::make_unique<Foo>());
+//       // Invokes the user function that takes ownership of the unique
+//       // pointer.
+//       phmap::apply(&user_function2, std::move(tuple2));
+//
+//       auto foo = phmap::make_unique<Foo>();
+//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
+//       // Invokes the method Bar on foo with one argument, 42.
+//       phmap::apply(&Foo::Bar, tuple3);
+//
+//       std::tuple<int, int> tuple4(8, 9);
+//       // Invokes a lambda.
+//       phmap::apply(user_lambda, tuple4);
+//   }
+template <typename Functor, typename Tuple>
+auto apply(Functor&& functor, Tuple&& t)
+    -> decltype(utility_internal::apply_helper(
+        phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
+        phmap::make_index_sequence<std::tuple_size<
+            typename std::remove_reference<Tuple>::type>::value>{})) {
+  return utility_internal::apply_helper(
+      phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
+      phmap::make_index_sequence<std::tuple_size<
+          typename std::remove_reference<Tuple>::type>::value>{});
+}
+
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4365) // '=': conversion from 'T' to 'T', signed/unsigned mismatch
+#endif  // _MSC_VER
+
+// exchange
+//
+// Replaces the value of `obj` with `new_value` and returns the old value of
+// `obj`.  `phmap::exchange` is designed to be a drop-in replacement for C++14's
+// `std::exchange`.
+//
+// Example:
+//
+//   Foo& operator=(Foo&& other) {
+//     ptr1_ = phmap::exchange(other.ptr1_, nullptr);
+//     int1_ = phmap::exchange(other.int1_, -1);
+//     return *this;
+//   }
+template <typename T, typename U = T>
+T exchange(T& obj, U&& new_value)
+{
+    T old_value = phmap::move(obj);
+    obj = phmap::forward<U>(new_value);
+    return old_value;
+}
+
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif  // _MSC_VER
+
+
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+//          memory.h
+// -----------------------------------------------------------------------------
+
+namespace phmap {
+
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) 
+{
+    static_assert(!std::is_array<T>::value, "array types are unsupported");
+    static_assert(std::is_object<T>::value, "non-object types are unsupported");
+    return std::unique_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// Traits to select proper overload and return type for `phmap::make_unique<>`.
+template <typename T>
+struct MakeUniqueResult {
+    using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+    using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+    using invalid = void;
+};
+
+}  // namespace memory_internal
+
+#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
+    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8) 
+    using std::make_unique;
+#else
+
+    template <typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
+        Args&&... args) {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+    
+    template <typename T>
+    typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
+        return std::unique_ptr<T>(new typename phmap::remove_extent_t<T>[n]());
+    }
+    
+    template <typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
+        Args&&... /* args */) = delete;
+#endif
+
+template <typename T>
+auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr))
+{
+    // ptr is a forwarding reference to support Ts with non-const operators.
+    return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
+}
+
+inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
+
+template <typename T, typename D>
+std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
+    return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
+}
+
+template <typename T>
+std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
+    return std::weak_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
+template <template <typename> class Extract, typename Obj, typename Default,
+          typename>
+struct ExtractOr {
+    using type = Default;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
+    using type = Extract<Obj>;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
+
+// Extractors for the features of allocators.
+template <typename T>
+using GetPointer = typename T::pointer;
+
+template <typename T>
+using GetConstPointer = typename T::const_pointer;
+
+template <typename T>
+using GetVoidPointer = typename T::void_pointer;
+
+template <typename T>
+using GetConstVoidPointer = typename T::const_void_pointer;
+
+template <typename T>
+using GetDifferenceType = typename T::difference_type;
+
+template <typename T>
+using GetSizeType = typename T::size_type;
+
+template <typename T>
+using GetPropagateOnContainerCopyAssignment =
+    typename T::propagate_on_container_copy_assignment;
+
+template <typename T>
+using GetPropagateOnContainerMoveAssignment =
+    typename T::propagate_on_container_move_assignment;
+
+template <typename T>
+using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
+
+template <typename T>
+using GetIsAlwaysEqual = typename T::is_always_equal;
+
+template <typename T>
+struct GetFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args>
+struct GetFirstArg<Class<T, Args...>> {
+  using type = T;
+};
+
+template <typename Ptr, typename = void>
+struct ElementType {
+  using type = typename GetFirstArg<Ptr>::type;
+};
+
+template <typename T>
+struct ElementType<T, void_t<typename T::element_type>> {
+  using type = typename T::element_type;
+};
+
+template <typename T, typename U>
+struct RebindFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args,
+          typename U>
+struct RebindFirstArg<Class<T, Args...>, U> {
+  using type = Class<U, Args...>;
+};
+
+template <typename T, typename U, typename = void>
+struct RebindPtr {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
+  using type = typename T::template rebind<U>;
+};
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(...) {
+  return false;
+}
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(typename std::allocator_traits<T>::template rebind_alloc<U>*) {
+  return true;
+}
+
+template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
+struct RebindAlloc {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename A, typename U>
+struct RebindAlloc<A, U, true> {
+    using type = typename std::allocator_traits<A>::template rebind_alloc<U>;
+};
+
+
+}  // namespace memory_internal
+
+template <typename Ptr>
+struct pointer_traits 
+{
+    using pointer = Ptr;
+
+    // element_type:
+    // Ptr::element_type if present. Otherwise T if Ptr is a template
+    // instantiation Template<T, Args...>
+    using element_type = typename memory_internal::ElementType<Ptr>::type;
+
+    // difference_type:
+    // Ptr::difference_type if present, otherwise std::ptrdiff_t
+    using difference_type =
+        memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
+                                    std::ptrdiff_t>;
+
+    // rebind:
+    // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
+    // template instantiation Template<T, Args...>
+    template <typename U>
+    using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
+
+    // pointer_to:
+    // Calls Ptr::pointer_to(r)
+    static pointer pointer_to(element_type& r) {  // NOLINT(runtime/references)
+        return Ptr::pointer_to(r);
+    }
+};
+
+// Specialization for T*.
+template <typename T>
+struct pointer_traits<T*> 
+{
+    using pointer = T*;
+    using element_type = T;
+    using difference_type = std::ptrdiff_t;
+
+    template <typename U>
+    using rebind = U*;
+
+    // pointer_to:
+    // Calls std::addressof(r)
+    static pointer pointer_to(
+        element_type& r) noexcept {  // NOLINT(runtime/references)
+        return std::addressof(r);
+    }
+};
+
+// -----------------------------------------------------------------------------
+// Class Template: allocator_traits
+// -----------------------------------------------------------------------------
+//
+// A C++11 compatible implementation of C++17's std::allocator_traits.
+//
+template <typename Alloc>
+struct allocator_traits 
+{
+    using allocator_type = Alloc;
+
+    // value_type:
+    // Alloc::value_type
+    using value_type = typename Alloc::value_type;
+
+    // pointer:
+    // Alloc::pointer if present, otherwise value_type*
+    using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
+                                                Alloc, value_type*>;
+
+    // const_pointer:
+    // Alloc::const_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<const value_type>
+    using const_pointer =
+        memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
+                                    typename phmap::pointer_traits<pointer>::
+                                    template rebind<const value_type>>;
+
+    // void_pointer:
+    // Alloc::void_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<void>
+    using void_pointer = memory_internal::ExtractOrT<
+        memory_internal::GetVoidPointer, Alloc,
+        typename phmap::pointer_traits<pointer>::template rebind<void>>;
+
+    // const_void_pointer:
+    // Alloc::const_void_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<const void>
+    using const_void_pointer = memory_internal::ExtractOrT<
+        memory_internal::GetConstVoidPointer, Alloc,
+        typename phmap::pointer_traits<pointer>::template rebind<const void>>;
+
+    // difference_type:
+    // Alloc::difference_type if present, otherwise
+    // phmap::pointer_traits<pointer>::difference_type
+    using difference_type = memory_internal::ExtractOrT<
+        memory_internal::GetDifferenceType, Alloc,
+        typename phmap::pointer_traits<pointer>::difference_type>;
+
+    // size_type:
+    // Alloc::size_type if present, otherwise
+    // std::make_unsigned<difference_type>::type
+    using size_type = memory_internal::ExtractOrT<
+        memory_internal::GetSizeType, Alloc,
+        typename std::make_unsigned<difference_type>::type>;
+
+    // propagate_on_container_copy_assignment:
+    // Alloc::propagate_on_container_copy_assignment if present, otherwise
+    // std::false_type
+    using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
+        memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
+        std::false_type>;
+
+    // propagate_on_container_move_assignment:
+    // Alloc::propagate_on_container_move_assignment if present, otherwise
+    // std::false_type
+    using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
+        memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
+        std::false_type>;
+
+    // propagate_on_container_swap:
+    // Alloc::propagate_on_container_swap if present, otherwise std::false_type
+    using propagate_on_container_swap =
+        memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
+                                    Alloc, std::false_type>;
+
+    // is_always_equal:
+    // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
+    using is_always_equal =
+        memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
+                                    typename std::is_empty<Alloc>::type>;
+
+    // rebind_alloc:
+    // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
+    // is Alloc<U, Args>
+    template <typename T>
+    using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
+
+    // rebind_traits:
+    // phmap::allocator_traits<rebind_alloc<T>>
+    template <typename T>
+    using rebind_traits = phmap::allocator_traits<rebind_alloc<T>>;
+
+    // allocate(Alloc& a, size_type n):
+    // Calls a.allocate(n)
+    static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
+                            size_type n) {
+        return a.allocate(n);
+    }
+
+    // allocate(Alloc& a, size_type n, const_void_pointer hint):
+    // Calls a.allocate(n, hint) if possible.
+    // If not possible, calls a.allocate(n)
+    static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
+                            const_void_pointer hint) {
+        return allocate_impl(0, a, n, hint);
+    }
+
+    // deallocate(Alloc& a, pointer p, size_type n):
+    // Calls a.deallocate(p, n)
+    static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
+                           size_type n) {
+        a.deallocate(p, n);
+    }
+
+    // construct(Alloc& a, T* p, Args&&... args):
+    // Calls a.construct(p, std::forward<Args>(args)...) if possible.
+    // If not possible, calls
+    //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
+    template <typename T, typename... Args>
+    static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
+                          Args&&... args) {
+        construct_impl(0, a, p, std::forward<Args>(args)...);
+    }
+
+    // destroy(Alloc& a, T* p):
+    // Calls a.destroy(p) if possible. If not possible, calls p->~T().
+    template <typename T>
+    static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
+        destroy_impl(0, a, p);
+    }
+
+    // max_size(const Alloc& a):
+    // Returns a.max_size() if possible. If not possible, returns
+    //   std::numeric_limits<size_type>::max() / sizeof(value_type)
+    static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
+
+    // select_on_container_copy_construction(const Alloc& a):
+    // Returns a.select_on_container_copy_construction() if possible.
+    // If not possible, returns a.
+    static Alloc select_on_container_copy_construction(const Alloc& a) {
+        return select_on_container_copy_construction_impl(0, a);
+    }
+
+private:
+    template <typename A>
+    static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
+                              size_type n, const_void_pointer hint)
+        -> decltype(a.allocate(n, hint)) {
+        return a.allocate(n, hint);
+    }
+    static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
+                                 size_type n, const_void_pointer) {
+        return a.allocate(n);
+    }
+
+    template <typename A, typename... Args>
+    static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
+                               Args&&... args)
+        -> decltype(std::allocator_traits<A>::construct(a, std::forward<Args>(args)...)) {
+        std::allocator_traits<A>::construct(a, std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static void construct_impl(char, Alloc&, T* p, Args&&... args) {
+        ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+    }
+
+    template <typename A, typename T>
+    static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
+                             T* p) -> decltype(std::allocator_traits<A>::destroy(a, p)) {
+        std::allocator_traits<A>::destroy(a, p);
+    }
+    template <typename T>
+    static void destroy_impl(char, Alloc&, T* p) {
+        p->~T();
+    }
+
+    template <typename A>
+    static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
+        return a.max_size();
+    }
+    static size_type max_size_impl(char, const Alloc&) {
+        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+    }
+
+    template <typename A>
+    static auto select_on_container_copy_construction_impl(int, const A& a)
+        -> decltype(a.select_on_container_copy_construction()) {
+        return a.select_on_container_copy_construction();
+    }
+    static Alloc select_on_container_copy_construction_impl(char,
+                                                            const Alloc& a) {
+        return a;
+    }
+};
+
+namespace memory_internal {
+
+// This template alias transforms Alloc::is_nothrow into a metafunction with
+// Alloc as a parameter so it can be used with ExtractOrT<>.
+template <typename Alloc>
+using GetIsNothrow = typename Alloc::is_nothrow;
+
+}  // namespace memory_internal
+
+// PHMAP_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+// specify whether the default allocation function can throw or never throws.
+// If the allocation function never throws, user should define it to a non-zero
+// value (e.g. via `-DPHMAP_ALLOCATOR_NOTHROW`).
+// If the allocation function can throw, user should leave it undefined or
+// define it to zero.
+//
+// allocator_is_nothrow<Alloc> is a traits class that derives from
+// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
+// for Alloc = std::allocator<T> for any type T according to the state of
+// PHMAP_ALLOCATOR_NOTHROW.
+//
+// default_allocator_is_nothrow is a class that derives from std::true_type
+// when the default allocator (global operator new) never throws, and
+// std::false_type when it can throw. It is a convenience shorthand for writing
+// allocator_is_nothrow<std::allocator<T>> (T can be any type).
+// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
+// the same type for all T, because users should specialize neither
+// allocator_is_nothrow nor std::allocator.
+template <typename Alloc>
+struct allocator_is_nothrow
+    : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
+                                  std::false_type> {};
+
+#if defined(PHMAP_ALLOCATOR_NOTHROW) && PHMAP_ALLOCATOR_NOTHROW
+    template <typename T>
+    struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
+    struct default_allocator_is_nothrow : std::true_type {};
+#else
+    struct default_allocator_is_nothrow : std::false_type {};
+#endif
+
+namespace memory_internal {
+template <typename Allocator, typename Iterator, typename... Args>
+void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
+                    const Args&... args) 
+{
+    for (Iterator cur = first; cur != last; ++cur) {
+        PHMAP_INTERNAL_TRY {
+            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                        args...);
+        }
+        PHMAP_INTERNAL_CATCH_ANY {
+            while (cur != first) {
+                --cur;
+                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+            }
+            PHMAP_INTERNAL_RETHROW;
+        }
+    }
+}
+
+template <typename Allocator, typename Iterator, typename InputIterator>
+void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
+               InputIterator last) 
+{
+    for (Iterator cur = destination; first != last;
+         static_cast<void>(++cur), static_cast<void>(++first)) {
+        PHMAP_INTERNAL_TRY {
+            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                        *first);
+        }
+        PHMAP_INTERNAL_CATCH_ANY {
+            while (cur != destination) {
+                --cur;
+                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+            }
+            PHMAP_INTERNAL_RETHROW;
+        }
+    }
+}
+}  // namespace memory_internal
+}  // namespace phmap
+
+
+// -----------------------------------------------------------------------------
+//          optional.h
+// -----------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+
+#include <optional>  // IWYU pragma: export
+
+namespace phmap {
+using std::bad_optional_access;
+using std::optional;
+using std::make_optional;
+using std::nullopt_t;
+using std::nullopt;
+}  // namespace phmap
+
+#else
+
+#if defined(__clang__)
+    #if __has_feature(cxx_inheriting_constructors)
+        #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+    #endif
+#elif (defined(__GNUC__) &&                                       \
+       (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
+    (__cpp_inheriting_constructors >= 200802) ||                  \
+    (defined(_MSC_VER) && _MSC_VER >= 1910)
+
+    #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+
+namespace phmap {
+
+class bad_optional_access : public std::exception 
+{
+public:
+    bad_optional_access() = default;
+    ~bad_optional_access() override;
+    const char* what() const noexcept override;
+};
+
+template <typename T>
+class optional;
+
+// --------------------------------
+struct nullopt_t 
+{
+    struct init_t {};
+    static init_t init;
+
+    explicit constexpr nullopt_t(init_t& /*unused*/) {}
+};
+
+constexpr nullopt_t nullopt(nullopt_t::init);
+
+namespace optional_internal {
+
+// throw delegator
+[[noreturn]] void throw_bad_optional_access();
+
+
+struct empty_struct {};
+
+// This class stores the data in optional<T>.
+// It is specialized based on whether T is trivially destructible.
+// This is the specialization for non trivially destructible type.
+template <typename T, bool unused = std::is_trivially_destructible<T>::value>
+class optional_data_dtor_base 
+{
+    struct dummy_type {
+        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+        // Use an array to avoid GCC 6 placement-new warning.
+        empty_struct data[sizeof(T) / sizeof(empty_struct)];
+    };
+
+protected:
+    // Whether there is data or not.
+    bool engaged_;
+    // Data storage
+    union {
+        dummy_type dummy_;
+        T data_;
+    };
+
+    void destruct() noexcept {
+        if (engaged_) {
+            data_.~T();
+            engaged_ = false;
+        }
+    }
+
+    // dummy_ must be initialized for constexpr constructor.
+    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+    template <typename... Args>
+    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
+
+    ~optional_data_dtor_base() { destruct(); }
+};
+
+// Specialization for trivially destructible type.
+template <typename T>
+class optional_data_dtor_base<T, true> 
+{
+    struct dummy_type {
+        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+        // Use array to avoid GCC 6 placement-new warning.
+        empty_struct data[sizeof(T) / sizeof(empty_struct)];
+    };
+
+protected:
+    // Whether there is data or not.
+    bool engaged_;
+    // Data storage
+    union {
+        dummy_type dummy_;
+        T data_;
+    };
+    void destruct() noexcept { engaged_ = false; }
+
+    // dummy_ must be initialized for constexpr constructor.
+    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+    template <typename... Args>
+    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
+};
+
+template <typename T>
+class optional_data_base : public optional_data_dtor_base<T> 
+{
+protected:
+    using base = optional_data_dtor_base<T>;
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using base::base;
+#else
+    optional_data_base() = default;
+
+    template <typename... Args>
+    constexpr explicit optional_data_base(in_place_t t, Args&&... args)
+        : base(t, phmap::forward<Args>(args)...) {}
+#endif
+
+    template <typename... Args>
+    void construct(Args&&... args) {
+        // Use dummy_'s address to work around casting cv-qualified T* to void*.
+        ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
+        this->engaged_ = true;
+    }
+
+    template <typename U>
+    void assign(U&& u) {
+        if (this->engaged_) {
+            this->data_ = std::forward<U>(u);
+        } else {
+            construct(std::forward<U>(u));
+        }
+    }
+};
+
+// TODO: Add another class using
+// std::is_trivially_move_constructible trait when available to match
+// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
+// have trivial move but nontrivial copy.
+// Also, we should be checking is_trivially_copyable here, which is not
+// supported now, so we use is_trivially_* traits instead.
+template <typename T,
+          bool unused = phmap::is_trivially_copy_constructible<T>::value&&
+              phmap::is_trivially_copy_assignable<typename std::remove_cv<
+                  T>::type>::value&& std::is_trivially_destructible<T>::value>
+class optional_data;
+
+// Trivially copyable types
+template <typename T>
+class optional_data<T, true> : public optional_data_base<T> 
+{
+protected:
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using optional_data_base<T>::optional_data_base;
+#else
+    optional_data() = default;
+
+    template <typename... Args>
+    constexpr explicit optional_data(in_place_t t, Args&&... args)
+        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
+#endif
+};
+
+template <typename T>
+class optional_data<T, false> : public optional_data_base<T> 
+{
+protected:
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using optional_data_base<T>::optional_data_base;
+#else
+    template <typename... Args>
+    constexpr explicit optional_data(in_place_t t, Args&&... args)
+        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
+#endif
+
+    optional_data() = default;
+
+    optional_data(const optional_data& rhs) : optional_data_base<T>() {
+        if (rhs.engaged_) {
+            this->construct(rhs.data_);
+        }
+    }
+
+    optional_data(optional_data&& rhs) noexcept(
+        phmap::default_allocator_is_nothrow::value ||
+        std::is_nothrow_move_constructible<T>::value)
+    : optional_data_base<T>() {
+        if (rhs.engaged_) {
+            this->construct(std::move(rhs.data_));
+        }
+    }
+
+    optional_data& operator=(const optional_data& rhs) {
+        if (rhs.engaged_) {
+            this->assign(rhs.data_);
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    optional_data& operator=(optional_data&& rhs) noexcept(
+        std::is_nothrow_move_assignable<T>::value&&
+        std::is_nothrow_move_constructible<T>::value) {
+        if (rhs.engaged_) {
+            this->assign(std::move(rhs.data_));
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+};
+
+// Ordered by level of restriction, from low to high.
+// Copyable implies movable.
+enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
+
+// Base class for enabling/disabling copy/move constructor.
+template <copy_traits>
+class optional_ctor_base;
+
+template <>
+class optional_ctor_base<copy_traits::copyable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = default;
+    optional_ctor_base(optional_ctor_base&&) = default;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::movable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = delete;
+    optional_ctor_base(optional_ctor_base&&) = default;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::non_movable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = delete;
+    optional_ctor_base(optional_ctor_base&&) = delete;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+// Base class for enabling/disabling copy/move assignment.
+template <copy_traits>
+class optional_assign_base;
+
+template <>
+class optional_assign_base<copy_traits::copyable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = default;
+    optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::movable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = delete;
+    optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::non_movable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = delete;
+    optional_assign_base& operator=(optional_assign_base&&) = delete;
+};
+
+template <typename T>
+constexpr copy_traits get_ctor_copy_traits() 
+{
+    return std::is_copy_constructible<T>::value
+        ? copy_traits::copyable
+        : std::is_move_constructible<T>::value ? copy_traits::movable
+        : copy_traits::non_movable;
+}
+
+template <typename T>
+constexpr copy_traits get_assign_copy_traits() 
+{
+    return phmap::is_copy_assignable<T>::value &&
+                 std::is_copy_constructible<T>::value
+             ? copy_traits::copyable
+             : phmap::is_move_assignable<T>::value &&
+                       std::is_move_constructible<T>::value
+                   ? copy_traits::movable
+                   : copy_traits::non_movable;
+}
+
+// Whether T is constructible or convertible from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_from_optional
+    : std::integral_constant<
+          bool, std::is_constructible<T, optional<U>&>::value ||
+                    std::is_constructible<T, optional<U>&&>::value ||
+                    std::is_constructible<T, const optional<U>&>::value ||
+                    std::is_constructible<T, const optional<U>&&>::value ||
+                    std::is_convertible<optional<U>&, T>::value ||
+                    std::is_convertible<optional<U>&&, T>::value ||
+                    std::is_convertible<const optional<U>&, T>::value ||
+                    std::is_convertible<const optional<U>&&, T>::value> {};
+
+// Whether T is constructible or convertible or assignable from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_assignable_from_optional
+    : std::integral_constant<
+          bool, is_constructible_convertible_from_optional<T, U>::value ||
+                    std::is_assignable<T&, optional<U>&>::value ||
+                    std::is_assignable<T&, optional<U>&&>::value ||
+                    std::is_assignable<T&, const optional<U>&>::value ||
+                    std::is_assignable<T&, const optional<U>&&>::value> {};
+
+// Helper function used by [optional.relops], [optional.comp_with_t],
+// for checking whether an expression is convertible to bool.
+bool convertible_to_bool(bool);
+
+// Base class for std::hash<phmap::optional<T>>:
+// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
+// compute the hash; Otherwise, it is disabled.
+// Reference N4659 23.14.15 [unord.hash].
+template <typename T, typename = size_t>
+struct optional_hash_base 
+{
+    optional_hash_base() = delete;
+    optional_hash_base(const optional_hash_base&) = delete;
+    optional_hash_base(optional_hash_base&&) = delete;
+    optional_hash_base& operator=(const optional_hash_base&) = delete;
+    optional_hash_base& operator=(optional_hash_base&&) = delete;
+};
+
+template <typename T>
+struct optional_hash_base<T, decltype(std::hash<phmap::remove_const_t<T> >()(
+                                 std::declval<phmap::remove_const_t<T> >()))> 
+{
+    using argument_type = phmap::optional<T>;
+    using result_type = size_t;
+    size_t operator()(const phmap::optional<T>& opt) const {
+        phmap::type_traits_internal::AssertHashEnabled<phmap::remove_const_t<T>>();
+        if (opt) {
+            return std::hash<phmap::remove_const_t<T> >()(*opt);
+        } else {
+            return static_cast<size_t>(0x297814aaad196e6dULL);
+        }
+    }
+};
+
+}  // namespace optional_internal
+
+
+// -----------------------------------------------------------------------------
+// phmap::optional class definition
+// -----------------------------------------------------------------------------
+
+template <typename T>
+class optional : private optional_internal::optional_data<T>,
+                 private optional_internal::optional_ctor_base<
+                     optional_internal::get_ctor_copy_traits<T>()>,
+                 private optional_internal::optional_assign_base<
+                     optional_internal::get_assign_copy_traits<T>()> 
+{
+    using data_base = optional_internal::optional_data<T>;
+
+public:
+    typedef T value_type;
+
+    // Constructors
+
+    // Constructs an `optional` holding an empty value, NOT a default constructed
+    // `T`.
+    constexpr optional() noexcept {}
+
+    // Constructs an `optional` initialized with `nullopt` to hold an empty value.
+    constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
+
+    // Copy constructor, standard semantics
+    optional(const optional& src) = default;
+
+    // Move constructor, standard semantics
+    optional(optional&& src) = default;
+
+    // Constructs a non-empty `optional` direct-initialized value of type `T` from
+    // the arguments `std::forward<Args>(args)...`  within the `optional`.
+    // (The `in_place_t` is a tag used to indicate that the contained object
+    // should be constructed in-place.)
+    template <typename InPlaceT, typename... Args,
+              phmap::enable_if_t<phmap::conjunction<
+                                    std::is_same<InPlaceT, in_place_t>,
+                                    std::is_constructible<T, Args&&...> >::value>* = nullptr>
+        constexpr explicit optional(InPlaceT, Args&&... args)
+        : data_base(in_place_t(), phmap::forward<Args>(args)...) {}
+
+    // Constructs a non-empty `optional` direct-initialized value of type `T` from
+    // the arguments of an initializer_list and `std::forward<Args>(args)...`.
+    // (The `in_place_t` is a tag used to indicate that the contained object
+    // should be constructed in-place.)
+    template <typename U, typename... Args,
+              typename = typename std::enable_if<std::is_constructible<
+                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
+        constexpr explicit optional(in_place_t, std::initializer_list<U> il,
+                                    Args&&... args)
+        : data_base(in_place_t(), il, phmap::forward<Args>(args)...) {
+    }
+
+    // Value constructor (implicit)
+    template <
+        typename U = T,
+        typename std::enable_if<
+            phmap::conjunction<phmap::negation<std::is_same<
+                                                 in_place_t, typename std::decay<U>::type> >,
+                              phmap::negation<std::is_same<
+                                                 optional<T>, typename std::decay<U>::type> >,
+                              std::is_convertible<U&&, T>,
+                              std::is_constructible<T, U&&> >::value,
+            bool>::type = false>
+        constexpr optional(U&& v) : data_base(in_place_t(), phmap::forward<U>(v)) {}
+
+    // Value constructor (explicit)
+    template <
+        typename U = T,
+        typename std::enable_if<
+            phmap::conjunction<phmap::negation<std::is_same<
+                                                 in_place_t, typename std::decay<U>::type>>,
+                              phmap::negation<std::is_same<
+                                                 optional<T>, typename std::decay<U>::type>>,
+                              phmap::negation<std::is_convertible<U&&, T>>,
+                              std::is_constructible<T, U&&>>::value,
+            bool>::type = false>
+        explicit constexpr optional(U&& v)
+        : data_base(in_place_t(), phmap::forward<U>(v)) {}
+
+    // Converting copy constructor (implicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U> >,
+                      std::is_constructible<T, const U&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U> >,
+                      std::is_convertible<const U&, T> >::value,
+                  bool>::type = false>
+    optional(const optional<U>& rhs) {
+        if (rhs) {
+            this->construct(*rhs);
+        }
+    }
+
+    // Converting copy constructor (explicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U>>,
+                      std::is_constructible<T, const U&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U>>,
+                      phmap::negation<std::is_convertible<const U&, T>>>::value,
+                  bool>::type = false>
+        explicit optional(const optional<U>& rhs) {
+        if (rhs) {
+            this->construct(*rhs);
+        }
+    }
+
+    // Converting move constructor (implicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U> >,
+                      std::is_constructible<T, U&&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U> >,
+                      std::is_convertible<U&&, T> >::value,
+                  bool>::type = false>
+        optional(optional<U>&& rhs) {
+        if (rhs) {
+            this->construct(std::move(*rhs));
+        }
+    }
+
+    // Converting move constructor (explicit)
+    template <
+        typename U,
+        typename std::enable_if<
+            phmap::conjunction<
+                phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+                phmap::negation<
+                    optional_internal::is_constructible_convertible_from_optional<
+                        T, U>>,
+                phmap::negation<std::is_convertible<U&&, T>>>::value,
+            bool>::type = false>
+        explicit optional(optional<U>&& rhs) {
+        if (rhs) {
+            this->construct(std::move(*rhs));
+        }
+    }
+
+    // Destructor. Trivial if `T` is trivially destructible.
+    ~optional() = default;
+
+    // Assignment Operators
+
+    // Assignment from `nullopt`
+    //
+    // Example:
+    //
+    //   struct S { int value; };
+    //   optional<S> opt = phmap::nullopt;  // Could also use opt = { };
+    optional& operator=(nullopt_t) noexcept {
+        this->destruct();
+        return *this;
+    }
+
+    // Copy assignment operator, standard semantics
+    optional& operator=(const optional& src) = default;
+
+    // Move assignment operator, standard semantics
+    optional& operator=(optional&& src) = default;
+
+    // Value assignment operators
+    template <
+        typename U = T,
+        typename = typename std::enable_if<phmap::conjunction<
+                                               phmap::negation<
+                                                   std::is_same<optional<T>, typename std::decay<U>::type>>,
+                                               phmap::negation<
+                                                   phmap::conjunction<std::is_scalar<T>,
+                                                                     std::is_same<T, typename std::decay<U>::type>>>,
+                                               std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type>
+        optional& operator=(U&& v) {
+        this->assign(std::forward<U>(v));
+        return *this;
+    }
+
+    template <
+        typename U,
+        typename = typename std::enable_if<phmap::conjunction<
+                                               phmap::negation<std::is_same<T, U>>,
+                                               std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
+                                               phmap::negation<
+                                                   optional_internal::
+                                                   is_constructible_convertible_assignable_from_optional<
+                                                       T, U>>>::value>::type>
+        optional& operator=(const optional<U>& rhs) {
+        if (rhs) {
+            this->assign(*rhs);
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    template <typename U,
+              typename = typename std::enable_if<phmap::conjunction<
+                                                     phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U>,
+                                                     std::is_assignable<T&, U>,
+                                                     phmap::negation<
+                                                         optional_internal::
+                                                         is_constructible_convertible_assignable_from_optional<
+                                                             T, U>>>::value>::type>
+        optional& operator=(optional<U>&& rhs) {
+        if (rhs) {
+            this->assign(std::move(*rhs));
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    // Modifiers
+
+    // optional::reset()
+    //
+    // Destroys the inner `T` value of an `phmap::optional` if one is present.
+    PHMAP_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
+
+    // optional::emplace()
+    //
+    // (Re)constructs the underlying `T` in-place with the given forwarded
+    // arguments.
+    //
+    // Example:
+    //
+    //   optional<Foo> opt;
+    //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
+    //
+    // If the optional is non-empty, and the `args` refer to subobjects of the
+    // current object, then behaviour is undefined, because the current object
+    // will be destructed before the new object is constructed with `args`.
+    template <typename... Args,
+              typename = typename std::enable_if<
+                  std::is_constructible<T, Args&&...>::value>::type>
+        T& emplace(Args&&... args) {
+        this->destruct();
+        this->construct(std::forward<Args>(args)...);
+        return reference();
+    }
+
+    // Emplace reconstruction overload for an initializer list and the given
+    // forwarded arguments.
+    //
+    // Example:
+    //
+    //   struct Foo {
+    //     Foo(std::initializer_list<int>);
+    //   };
+    //
+    //   optional<Foo> opt;
+    //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
+    template <typename U, typename... Args,
+              typename = typename std::enable_if<std::is_constructible<
+                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
+        T& emplace(std::initializer_list<U> il, Args&&... args) {
+        this->destruct();
+        this->construct(il, std::forward<Args>(args)...);
+        return reference();
+    }
+
+    // Swaps
+
+    // Swap, standard semantics
+    void swap(optional& rhs) noexcept(
+        std::is_nothrow_move_constructible<T>::value&&
+        std::is_trivial<T>::value) {
+        if (*this) {
+            if (rhs) {
+                using std::swap;
+                swap(**this, *rhs);
+            } else {
+                rhs.construct(std::move(**this));
+                this->destruct();
+            }
+        } else {
+            if (rhs) {
+                this->construct(std::move(*rhs));
+                rhs.destruct();
+            } else {
+                // No effect (swap(disengaged, disengaged)).
+            }
+        }
+    }
+
+    // Observers
+
+    // optional::operator->()
+    //
+    // Accesses the underlying `T` value's member `m` of an `optional`. If the
+    // `optional` is empty, behavior is undefined.
+    //
+    // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
+    const T* operator->() const {
+        assert(this->engaged_);
+        return std::addressof(this->data_);
+    }
+    T* operator->() {
+        assert(this->engaged_);
+        return std::addressof(this->data_);
+    }
+
+    // optional::operator*()
+    //
+    // Accesses the underlying `T` value of an `optional`. If the `optional` is
+    // empty, behavior is undefined.
+    constexpr const T& operator*() const & { return reference(); }
+    T& operator*() & {
+        assert(this->engaged_);
+        return reference();
+    }
+    constexpr const T&& operator*() const && {
+        return phmap::move(reference());
+    }
+    T&& operator*() && {
+        assert(this->engaged_);
+        return std::move(reference());
+    }
+
+    // optional::operator bool()
+    //
+    // Returns false if and only if the `optional` is empty.
+    //
+    //   if (opt) {
+    //     // do something with opt.value();
+    //   } else {
+    //     // opt is empty.
+    //   }
+    //
+    constexpr explicit operator bool() const noexcept { return this->engaged_; }
+
+    // optional::has_value()
+    //
+    // Determines whether the `optional` contains a value. Returns `false` if and
+    // only if `*this` is empty.
+    constexpr bool has_value() const noexcept { return this->engaged_; }
+
+// Suppress bogus warning on MSVC: MSVC complains call to reference() after
+// throw_bad_optional_access() is unreachable.
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4702)
+#endif  // _MSC_VER
+    // optional::value()
+    //
+    // Returns a reference to an `optional`s underlying value. The constness
+    // and lvalue/rvalue-ness of the `optional` is preserved to the view of
+    // the `T` sub-object. Throws `phmap::bad_optional_access` when the `optional`
+    // is empty.
+    constexpr const T& value() const & {
+        return static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference());
+    }
+    T& value() & {
+        return static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference());
+    }
+    T&& value() && {  // NOLINT(build/c++11)
+        return std::move(
+            static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+    }
+    constexpr const T&& value() const && {  // NOLINT(build/c++11)
+        return phmap::move(
+            static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+    }
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif  // _MSC_VER
+
+    // optional::value_or()
+    //
+    // Returns either the value of `T` or a passed default `v` if the `optional`
+    // is empty.
+    template <typename U>
+    constexpr T value_or(U&& v) const& {
+        static_assert(std::is_copy_constructible<value_type>::value,
+                      "optional<T>::value_or: T must by copy constructible");
+        static_assert(std::is_convertible<U&&, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return static_cast<bool>(*this)
+            ? **this
+            : static_cast<T>(phmap::forward<U>(v));
+    }
+    template <typename U>
+    T value_or(U&& v) && {  // NOLINT(build/c++11)
+        static_assert(std::is_move_constructible<value_type>::value,
+                      "optional<T>::value_or: T must by move constructible");
+        static_assert(std::is_convertible<U&&, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return static_cast<bool>(*this) ? std::move(**this)
+            : static_cast<T>(std::forward<U>(v));
+    }
+
+private:
+    // Private accessors for internal storage viewed as reference to T.
+    constexpr const T& reference() const { return this->data_; }
+    T& reference() { return this->data_; }
+
+    // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
+    // or a reference.
+    static_assert(
+        !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
+        "optional<nullopt_t> is not allowed.");
+    static_assert(
+        !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
+        "optional<in_place_t> is not allowed.");
+    static_assert(!std::is_reference<T>::value,
+                  "optional<reference> is not allowed.");
+};
+
+// Non-member functions
+
+// swap()
+//
+// Performs a swap between two `phmap::optional` objects, using standard
+// semantics.
+//
+// NOTE: we assume `is_swappable()` is always `true`. A compile error will
+// result if this is not the case.
+template <typename T,
+          typename std::enable_if<std::is_move_constructible<T>::value,
+                                  bool>::type = false>
+void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
+    a.swap(b);
+}
+
+// make_optional()
+//
+// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
+// `phmap::optional` can also be explicitly instantiated with
+// `make_optional<T>(v)`.
+//
+// Note: `make_optional()` constructions may be declared `constexpr` for
+// trivially copyable types `T`. Non-trivial types require copy elision
+// support in C++17 for `make_optional` to support `constexpr` on such
+// non-trivial types.
+//
+// Example:
+//
+//   constexpr phmap::optional<int> opt = phmap::make_optional(1);
+//   static_assert(opt.value() == 1, "");
+template <typename T>
+constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
+    return optional<typename std::decay<T>::type>(phmap::forward<T>(v));
+}
+
+template <typename T, typename... Args>
+constexpr optional<T> make_optional(Args&&... args) {
+    return optional<T>(in_place_t(), phmap::forward<Args>(args)...);
+}
+
+template <typename T, typename U, typename... Args>
+constexpr optional<T> make_optional(std::initializer_list<U> il,
+                                    Args&&... args) {
+    return optional<T>(in_place_t(), il,
+                       phmap::forward<Args>(args)...);
+}
+
+// Relational operators [optional.relops]
+
+// Empty optionals are considered equal to each other and less than non-empty
+// optionals. Supports relations between optional<T> and optional<U>, between
+// optional<T> and U, and between optional<T> and nullopt.
+//
+// Note: We're careful to support T having non-bool relationals.
+
+// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Returns:" statements are translated into
+// code in an obvious way here, and the original text retained as function docs.
+// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
+// otherwise *x == *y.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
+    return static_cast<bool>(x) != static_cast<bool>(y)
+             ? false
+             : static_cast<bool>(x) == false ? true
+                                             : static_cast<bool>(*x == *y);
+}
+
+// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
+// otherwise *x != *y.
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
+    return static_cast<bool>(x) != static_cast<bool>(y)
+             ? true
+             : static_cast<bool>(x) == false ? false
+                                             : static_cast<bool>(*x != *y);
+}
+// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
+    return !y ? false : !x ? true : static_cast<bool>(*x < *y);
+}
+// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
+    return !x ? false : !y ? true : static_cast<bool>(*x > *y);
+}
+// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
+    return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
+}
+// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
+    return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
+}
+
+// Comparison with nullopt [optional.nullops]
+// The C++17 (N4606) "Returns:" statements are used directly here.
+template <typename T>
+constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+    return false;
+}
+template <typename T>
+constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+    return true;
+}
+template <typename T>
+constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+    return false;
+}
+template <typename T>
+constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+    return true;
+}
+template <typename T>
+constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
+    return !x;
+}
+
+// Comparison with T [optional.comp_with_t]
+
+// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Equivalent to:" statements are used directly here.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator==(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
+}
+
+}  // namespace phmap
+
+namespace std {
+
+// std::hash specialization for phmap::optional.
+template <typename T>
+struct hash<phmap::optional<T> >
+    : phmap::optional_internal::optional_hash_base<T> {};
+
+}  // namespace std
+
+#endif
+
+// -----------------------------------------------------------------------------
+//          common.h
+// -----------------------------------------------------------------------------
+namespace phmap {
+namespace priv {
+
+template <class, class = void>
+struct IsTransparent : std::false_type {};
+template <class T>
+struct IsTransparent<T, phmap::void_t<typename T::is_transparent>>
+    : std::true_type {};
+
+template <bool is_transparent>
+struct KeyArg 
+{
+    // Transparent. Forward `K`.
+    template <typename K, typename key_type>
+    using type = K;
+};
+
+template <>
+struct KeyArg<false> 
+{
+    // Not transparent. Always use `key_type`.
+    template <typename K, typename key_type>
+    using type = key_type;
+};
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    //  warning C4820: '6' bytes padding added after data member
+    #pragma warning(disable : 4820)
+#endif
+
+// The node_handle concept from C++17.
+// We specialize node_handle for sets and maps. node_handle_base holds the
+// common API of both.
+// -----------------------------------------------------------------------
+template <typename PolicyTraits, typename Alloc>
+class node_handle_base 
+{
+protected:
+    using slot_type = typename PolicyTraits::slot_type;
+
+public:
+    using allocator_type = Alloc;
+
+    constexpr node_handle_base() {}
+
+    node_handle_base(node_handle_base&& other) noexcept {
+        *this = std::move(other);
+    }
+
+    ~node_handle_base() { destroy(); }
+
+    node_handle_base& operator=(node_handle_base&& other) noexcept {
+        destroy();
+        if (!other.empty()) {
+            alloc_ = other.alloc_;
+            PolicyTraits::transfer(alloc(), slot(), other.slot());
+            other.reset();
+        }
+        return *this;
+    }
+
+    bool empty() const noexcept { return !alloc_; }
+    explicit operator bool() const noexcept { return !empty(); }
+    allocator_type get_allocator() const { return *alloc_; }
+
+protected:
+    friend struct CommonAccess;
+
+    struct transfer_tag_t {};
+    node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
+        : alloc_(a) {
+        PolicyTraits::transfer(alloc(), slot(), s);
+    }
+    
+    struct move_tag_t {};
+    node_handle_base(move_tag_t, const allocator_type& a, slot_type* s)
+        : alloc_(a) {
+        PolicyTraits::construct(alloc(), slot(), s);
+    }
+
+    node_handle_base(const allocator_type& a, slot_type* s) : alloc_(a) {
+        PolicyTraits::transfer(alloc(), slot(), s);
+    }
+
+    //node_handle_base(const node_handle_base&) = delete;
+    //node_handle_base& operator=(const node_handle_base&) = delete;
+
+    void destroy() {
+        if (!empty()) {
+            PolicyTraits::destroy(alloc(), slot());
+            reset();
+        }
+    }
+
+    void reset() {
+        assert(alloc_.has_value());
+        alloc_ = phmap::nullopt;
+    }
+
+    slot_type* slot() const {
+        assert(!empty());
+        return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
+    }
+
+    allocator_type* alloc() { return std::addressof(*alloc_); }
+
+private:
+    phmap::optional<allocator_type> alloc_;
+    mutable phmap::aligned_storage_t<sizeof(slot_type), alignof(slot_type)> slot_space_;
+};
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+// For sets.
+// ---------
+template <typename Policy, typename PolicyTraits, typename Alloc,
+          typename = void>
+class node_handle : public node_handle_base<PolicyTraits, Alloc> 
+{
+    using Base = node_handle_base<PolicyTraits, Alloc>;
+
+public:
+    using value_type = typename PolicyTraits::value_type;
+
+    constexpr node_handle() {}
+
+    value_type& value() const { return PolicyTraits::element(this->slot()); }
+
+    value_type& key() const { return PolicyTraits::element(this->slot()); }
+
+private:
+    friend struct CommonAccess;
+
+    using Base::Base;
+};
+
+// For maps.
+// ---------
+template <typename Policy, typename PolicyTraits, typename Alloc>
+class node_handle<Policy, PolicyTraits, Alloc,
+                  phmap::void_t<typename Policy::mapped_type>>
+    : public node_handle_base<PolicyTraits, Alloc> 
+{
+    using Base = node_handle_base<PolicyTraits, Alloc>;
+    using slot_type = typename PolicyTraits::slot_type;
+
+public:
+    using key_type = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+
+    constexpr node_handle() {}
+
+    auto key() const -> decltype(PolicyTraits::key(this->slot())) {
+        return PolicyTraits::key(this->slot());
+    }
+
+    mapped_type& mapped() const {
+        return PolicyTraits::value(&PolicyTraits::element(this->slot()));
+    }
+
+private:
+    friend struct CommonAccess;
+
+    using Base::Base;
+};
+
+// Provide access to non-public node-handle functions.
+struct CommonAccess 
+{
+    template <typename Node>
+    static auto GetSlot(const Node& node) -> decltype(node.slot()) {
+        return node.slot();
+    }
+
+    template <typename Node>
+    static void Destroy(Node* node) {
+        node->destroy();
+    }
+
+    template <typename Node>
+    static void Reset(Node* node) {
+        node->reset();
+    }
+
+    template <typename T, typename... Args>
+    static T Make(Args&&... args) {
+        return T(std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static T Transfer(Args&&... args) {
+        return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static T Move(Args&&... args) {
+        return T(typename T::move_tag_t{}, std::forward<Args>(args)...);
+    }
+};
+
+// Implement the insert_return_type<> concept of C++17.
+template <class Iterator, class NodeType>
+struct InsertReturnType 
+{
+    Iterator position;
+    bool inserted;
+    NodeType node;
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+
+#ifdef ADDRESS_SANITIZER
+    #include <sanitizer/asan_interface.h>
+#endif
+
+// ---------------------------------------------------------------------------
+//  span.h
+// ---------------------------------------------------------------------------
+
+namespace phmap {
+
+template <typename T>
+class Span;
+
+namespace span_internal {
+// A constexpr min function
+constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
+
+// Wrappers for access to container data pointers.
+template <typename C>
+constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
+    -> decltype(c.data()) {
+  return c.data();
+}
+
+// Before C++17, std::string::data returns a const char* in all cases.
+inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
+                         int) noexcept {
+  return &s[0];
+}
+
+template <typename C>
+constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(GetDataImpl(c, 0)) {
+  return GetDataImpl(c, 0);
+}
+
+// Detection idioms for size() and data().
+template <typename C>
+using HasSize =
+    std::is_integral<phmap::decay_t<decltype(std::declval<C&>().size())>>;
+
+// We want to enable conversion from vector<T*> to Span<const T* const> but
+// disable conversion from vector<Derived> to Span<Base>. Here we use
+// the fact that U** is convertible to Q* const* if and only if Q is the same
+// type or a more cv-qualified version of U.  We also decay the result type of
+// data() to avoid problems with classes which have a member function data()
+// which returns a reference.
+template <typename T, typename C>
+using HasData =
+    std::is_convertible<phmap::decay_t<decltype(GetData(std::declval<C&>()))>*,
+                        T* const*>;
+
+// Extracts value type from a Container
+template <typename C>
+struct ElementType {
+  using type = typename phmap::remove_reference_t<C>::value_type;
+};
+
+template <typename T, size_t N>
+struct ElementType<T (&)[N]> {
+  using type = T;
+};
+
+template <typename C>
+using ElementT = typename ElementType<C>::type;
+
+template <typename T>
+using EnableIfMutable =
+    typename std::enable_if<!std::is_const<T>::value, int>::type;
+
+template <typename T>
+bool EqualImpl(Span<T> a, Span<T> b) {
+  static_assert(std::is_const<T>::value, "");
+  return std::equal(a.begin(), a.end(), b.begin(), b.end());
+}
+
+template <typename T>
+bool LessThanImpl(Span<T> a, Span<T> b) {
+  static_assert(std::is_const<T>::value, "");
+  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// The `IsConvertible` classes here are needed because of the
+// `std::is_convertible` bug in libcxx when compiled with GCC. This build
+// configuration is used by Android NDK toolchain. Reference link:
+// https://bugs.llvm.org/show_bug.cgi?id=27538.
+template <typename From, typename To>
+struct IsConvertibleHelper {
+  static std::true_type testval(To);
+  static std::false_type testval(...);
+
+  using type = decltype(testval(std::declval<From>()));
+};
+
+template <typename From, typename To>
+struct IsConvertible : IsConvertibleHelper<From, To>::type {};
+
+// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
+// older version of libcxx is not supported.
+template <typename From, typename To>
+using EnableIfConvertibleToSpanConst =
+    typename std::enable_if<IsConvertible<From, Span<const To>>::value>::type;
+}  // namespace span_internal
+
+//------------------------------------------------------------------------------
+// Span
+//------------------------------------------------------------------------------
+//
+// A `Span` is an "array view" type for holding a view of a contiguous data
+// array; the `Span` object does not and cannot own such data itself. A span
+// provides an easy way to provide overloads for anything operating on
+// contiguous sequences without needing to manage pointers and array lengths
+// manually.
+
+// A span is conceptually a pointer (ptr) and a length (size) into an already
+// existing array of contiguous memory; the array it represents references the
+// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
+// instead of raw pointers avoids many issues related to index out of bounds
+// errors.
+//
+// Spans may also be constructed from containers holding contiguous sequences.
+// Such containers must supply `data()` and `size() const` methods (e.g
+// `std::vector<T>`, `phmap::InlinedVector<T, N>`). All implicit conversions to
+// `phmap::Span` from such containers will create spans of type `const T`;
+// spans which can mutate their values (of type `T`) must use explicit
+// constructors.
+//
+// A `Span<T>` is somewhat analogous to an `phmap::string_view`, but for an array
+// of elements of type `T`. A user of `Span` must ensure that the data being
+// pointed to outlives the `Span` itself.
+//
+// You can construct a `Span<T>` in several ways:
+//
+//   * Explicitly from a reference to a container type
+//   * Explicitly from a pointer and size
+//   * Implicitly from a container type (but only for spans of type `const T`)
+//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
+//
+// Examples:
+//
+//   // Construct a Span explicitly from a container:
+//   std::vector<int> v = {1, 2, 3, 4, 5};
+//   auto span = phmap::Span<const int>(v);
+//
+//   // Construct a Span explicitly from a C-style array:
+//   int a[5] =  {1, 2, 3, 4, 5};
+//   auto span = phmap::Span<const int>(a);
+//
+//   // Construct a Span implicitly from a container
+//   void MyRoutine(phmap::Span<const int> a) {
+//     ...
+//   }
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v)                     // convert to Span<const T>
+//
+// Note that `Span` objects, in addition to requiring that the memory they
+// point to remains alive, must also ensure that such memory does not get
+// reallocated. Therefore, to avoid undefined behavior, containers with
+// associated span views should not invoke operations that may reallocate memory
+// (such as resizing) or invalidate iterators into the container.
+//
+// One common use for a `Span` is when passing arguments to a routine that can
+// accept a variety of array types (e.g. a `std::vector`, `phmap::InlinedVector`,
+// a C-style array, etc.). Instead of creating overloads for each case, you
+// can simply specify a `Span` as the argument to such a routine.
+//
+// Example:
+//
+//   void MyRoutine(phmap::Span<const int> a) {
+//     ...
+//   }
+//
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v);
+//
+//   phmap::InlinedVector<int, 4> my_inline_vector;
+//   MyRoutine(my_inline_vector);
+//
+//   // Explicit constructor from pointer,size
+//   int* my_array = new int[10];
+//   MyRoutine(phmap::Span<const int>(my_array, 10));
+template <typename T>
+class Span 
+{
+private:
+    // Used to determine whether a Span can be constructed from a container of
+    // type C.
+    template <typename C>
+    using EnableIfConvertibleFrom =
+        typename std::enable_if<span_internal::HasData<T, C>::value &&
+                                span_internal::HasSize<C>::value>::type;
+
+    // Used to SFINAE-enable a function when the slice elements are const.
+    template <typename U>
+    using EnableIfConstView =
+        typename std::enable_if<std::is_const<T>::value, U>::type;
+
+    // Used to SFINAE-enable a function when the slice elements are mutable.
+    template <typename U>
+    using EnableIfMutableView =
+        typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+public:
+    using value_type = phmap::remove_cv_t<T>;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+
+    static const size_type npos = ~(size_type(0));
+
+    constexpr Span() noexcept : Span(nullptr, 0) {}
+    constexpr Span(pointer array, size_type lgth) noexcept
+        : ptr_(array), len_(lgth) {}
+
+    // Implicit conversion constructors
+    template <size_t N>
+    constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+        : Span(a, N) {}
+
+    // Explicit reference constructor for a mutable `Span<T>` type. Can be
+    // replaced with MakeSpan() to infer the type parameter.
+    template <typename V, typename = EnableIfConvertibleFrom<V>,
+              typename = EnableIfMutableView<V>>
+        explicit Span(V& v) noexcept  // NOLINT(runtime/references)
+        : Span(span_internal::GetData(v), v.size()) {}
+
+    // Implicit reference constructor for a read-only `Span<const T>` type
+    template <typename V, typename = EnableIfConvertibleFrom<V>,
+              typename = EnableIfConstView<V>>
+        constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
+        : Span(span_internal::GetData(v), v.size()) {}
+
+    // Implicit constructor from an initializer list, making it possible to pass a
+    // brace-enclosed initializer list to a function expecting a `Span`. Such
+    // spans constructed from an initializer list must be of type `Span<const T>`.
+    //
+    //   void Process(phmap::Span<const int> x);
+    //   Process({1, 2, 3});
+    //
+    // Note that as always the array referenced by the span must outlive the span.
+    // Since an initializer list constructor acts as if it is fed a temporary
+    // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
+    // constructor only when the `std::initializer_list` itself outlives the span.
+    // In order to meet this requirement it's sufficient to ensure that neither
+    // the span nor a copy of it is used outside of the expression in which it's
+    // created:
+    //
+    //   // Assume that this function uses the array directly, not retaining any
+    //   // copy of the span or pointer to any of its elements.
+    //   void Process(phmap::Span<const int> ints);
+    //
+    //   // Okay: the std::initializer_list<int> will reference a temporary array
+    //   // that isn't destroyed until after the call to Process returns.
+    //   Process({ 17, 19 });
+    //
+    //   // Not okay: the storage used by the std::initializer_list<int> is not
+    //   // allowed to be referenced after the first line.
+    //   phmap::Span<const int> ints = { 17, 19 };
+    //   Process(ints);
+    //
+    //   // Not okay for the same reason as above: even when the elements of the
+    //   // initializer list expression are not temporaries the underlying array
+    //   // is, so the initializer list must still outlive the span.
+    //   const int foo = 17;
+    //   phmap::Span<const int> ints = { foo };
+    //   Process(ints);
+    //
+    template <typename LazyT = T,
+              typename = EnableIfConstView<LazyT>>
+        Span(
+            std::initializer_list<value_type> v) noexcept  // NOLINT(runtime/explicit)
+        : Span(v.begin(), v.size()) {}
+
+    // Accessors
+
+    // Span::data()
+    //
+    // Returns a pointer to the span's underlying array of data (which is held
+    // outside the span).
+    constexpr pointer data() const noexcept { return ptr_; }
+
+    // Span::size()
+    //
+    // Returns the size of this span.
+    constexpr size_type size() const noexcept { return len_; }
+
+    // Span::length()
+    //
+    // Returns the length (size) of this span.
+    constexpr size_type length() const noexcept { return size(); }
+
+    // Span::empty()
+    //
+    // Returns a boolean indicating whether or not this span is considered empty.
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+    // Span::operator[]
+    //
+    // Returns a reference to the i'th element of this span.
+    constexpr reference operator[](size_type i) const noexcept {
+        // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+        return *(data() + i);
+    }
+
+    // Span::at()
+    //
+    // Returns a reference to the i'th element of this span.
+    constexpr reference at(size_type i) const {
+        return PHMAP_PREDICT_TRUE(i < size())  //
+            ? *(data() + i)
+            : (base_internal::ThrowStdOutOfRange(
+                   "Span::at failed bounds check"),
+               *(data() + i));
+    }
+
+    // Span::front()
+    //
+    // Returns a reference to the first element of this span.
+    constexpr reference front() const noexcept {
+        return PHMAP_ASSERT(size() > 0), *data();
+    }
+
+    // Span::back()
+    //
+    // Returns a reference to the last element of this span.
+    constexpr reference back() const noexcept {
+        return PHMAP_ASSERT(size() > 0), *(data() + size() - 1);
+    }
+
+    // Span::begin()
+    //
+    // Returns an iterator to the first element of this span.
+    constexpr iterator begin() const noexcept { return data(); }
+
+    // Span::cbegin()
+    //
+    // Returns a const iterator to the first element of this span.
+    constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+    // Span::end()
+    //
+    // Returns an iterator to the last element of this span.
+    constexpr iterator end() const noexcept { return data() + size(); }
+
+    // Span::cend()
+    //
+    // Returns a const iterator to the last element of this span.
+    constexpr const_iterator cend() const noexcept { return end(); }
+
+    // Span::rbegin()
+    //
+    // Returns a reverse iterator starting at the last element of this span.
+    constexpr reverse_iterator rbegin() const noexcept {
+        return reverse_iterator(end());
+    }
+
+    // Span::crbegin()
+    //
+    // Returns a reverse const iterator starting at the last element of this span.
+    constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+    // Span::rend()
+    //
+    // Returns a reverse iterator starting at the first element of this span.
+    constexpr reverse_iterator rend() const noexcept {
+        return reverse_iterator(begin());
+    }
+
+    // Span::crend()
+    //
+    // Returns a reverse iterator starting at the first element of this span.
+    constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+    // Span mutations
+
+    // Span::remove_prefix()
+    //
+    // Removes the first `n` elements from the span.
+    void remove_prefix(size_type n) noexcept {
+        assert(size() >= n);
+        ptr_ += n;
+        len_ -= n;
+    }
+
+    // Span::remove_suffix()
+    //
+    // Removes the last `n` elements from the span.
+    void remove_suffix(size_type n) noexcept {
+        assert(size() >= n);
+        len_ -= n;
+    }
+
+    // Span::subspan()
+    //
+    // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
+    // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
+    // must be <= size(). Any `len` value that points past the end of the span
+    // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
+    // ensures the returned subspan continues until the end of the span.
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).subspan(1, 2);  // {11, 12}
+    //   phmap::MakeSpan(vec).subspan(2, 8);  // {12, 13}
+    //   phmap::MakeSpan(vec).subspan(1);     // {11, 12, 13}
+    //   phmap::MakeSpan(vec).subspan(4);     // {}
+    //   phmap::MakeSpan(vec).subspan(5);     // throws std::out_of_range
+    constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
+        return (pos <= size())
+            ? Span(data() + pos, span_internal::Min(size() - pos, len))
+            : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+    }
+
+    // Span::first()
+    //
+    // Returns a `Span` containing first `len` elements. Parameter `len` is of
+    // type `size_type` and thus non-negative. `len` value must be <= size().
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).first(1);  // {10}
+    //   phmap::MakeSpan(vec).first(3);  // {10, 11, 12}
+    //   phmap::MakeSpan(vec).first(5);  // throws std::out_of_range
+    constexpr Span first(size_type len) const {
+        return (len <= size())
+            ? Span(data(), len)
+            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    }
+
+    // Span::last()
+    //
+    // Returns a `Span` containing last `len` elements. Parameter `len` is of
+    // type `size_type` and thus non-negative. `len` value must be <= size().
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).last(1);  // {13}
+    //   phmap::MakeSpan(vec).last(3);  // {11, 12, 13}
+    //   phmap::MakeSpan(vec).last(5);  // throws std::out_of_range
+    constexpr Span last(size_type len) const {
+        return (len <= size())
+            ? Span(size() - len + data(), len)
+            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    }
+
+    // Support for phmap::Hash.
+    template <typename H>
+    friend H AbslHashValue(H h, Span v) {
+        return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
+                          v.size());
+    }
+
+private:
+    pointer ptr_;
+    size_type len_;
+};
+
+template <typename T>
+const typename Span<T>::size_type Span<T>::npos;
+
+// Span relationals
+
+// Equality is compared element-by-element, while ordering is lexicographical.
+// We provide three overloads for each operator to cover any combination on the
+// left or right hand side of mutable Span<T>, read-only Span<const T>, and
+// convertible-to-read-only Span<T>.
+// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
+// template functions, 5 overloads per operator is needed as a workaround. We
+// should update them to 3 overloads per operator using non-deduced context like
+// string_view, i.e.
+// - (Span<T>, Span<T>)
+// - (Span<T>, non_deduced<Span<const T>>)
+// - (non_deduced<Span<const T>>, Span<T>)
+
+// operator==
+template <typename T>
+bool operator==(Span<T> a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator==(Span<const T> a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator==(Span<T> a, Span<const T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(const U& a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(Span<T> a, const U& b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+// operator!=
+template <typename T>
+bool operator!=(Span<T> a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T>
+bool operator!=(Span<const T> a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T>
+bool operator!=(Span<T> a, Span<const T> b) {
+  return !(a == b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(const U& a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(Span<T> a, const U& b) {
+  return !(a == b);
+}
+
+// operator<
+template <typename T>
+bool operator<(Span<T> a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator<(Span<const T> a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator<(Span<T> a, Span<const T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(const U& a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(Span<T> a, const U& b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+// operator>
+template <typename T>
+bool operator>(Span<T> a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T>
+bool operator>(Span<const T> a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T>
+bool operator>(Span<T> a, Span<const T> b) {
+  return b < a;
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(const U& a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(Span<T> a, const U& b) {
+  return b < a;
+}
+
+// operator<=
+template <typename T>
+bool operator<=(Span<T> a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T>
+bool operator<=(Span<const T> a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T>
+bool operator<=(Span<T> a, Span<const T> b) {
+  return !(b < a);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(const U& a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(Span<T> a, const U& b) {
+  return !(b < a);
+}
+
+// operator>=
+template <typename T>
+bool operator>=(Span<T> a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T>
+bool operator>=(Span<const T> a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T>
+bool operator>=(Span<T> a, Span<const T> b) {
+  return !(a < b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(const U& a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(Span<T> a, const U& b) {
+  return !(a < b);
+}
+
+// MakeSpan()
+//
+// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
+// container or pointer+size.
+//
+// Because a read-only `Span<const T>` is implicitly constructed from container
+// types regardless of whether the container itself is a const container,
+// constructing mutable spans of type `Span<T>` from containers requires
+// explicit constructors. The container-accepting version of `MakeSpan()`
+// deduces the type of `T` by the constness of the pointer received from the
+// container's `data()` member. Similarly, the pointer-accepting version returns
+// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
+//
+// Examples:
+//
+//   void MyRoutine(phmap::Span<MyComplicatedType> a) {
+//     ...
+//   };
+//   // my_vector is a container of non-const types
+//   std::vector<MyComplicatedType> my_vector;
+//
+//   // Constructing a Span implicitly attempts to create a Span of type
+//   // `Span<const T>`
+//   MyRoutine(my_vector);                // error, type mismatch
+//
+//   // Explicitly constructing the Span is verbose
+//   MyRoutine(phmap::Span<MyComplicatedType>(my_vector));
+//
+//   // Use MakeSpan() to make an phmap::Span<T>
+//   MyRoutine(phmap::MakeSpan(my_vector));
+//
+//   // Construct a span from an array ptr+size
+//   phmap::Span<T> my_span() {
+//     return phmap::MakeSpan(&array[0], num_elements_);
+//   }
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
+  return Span<T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<T> MakeSpan(T* begin, T* end) noexcept {
+  return PHMAP_ASSERT(begin <= end), Span<T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size())) {
+  return MakeSpan(span_internal::GetData(c), c.size());
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
+  return Span<T>(array, N);
+}
+
+// MakeConstSpan()
+//
+// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
+// but always returning a `Span<const T>`.
+//
+// Examples:
+//
+//   void ProcessInts(phmap::Span<const int> some_ints);
+//
+//   // Call with a pointer and size.
+//   int array[3] = { 0, 0, 0 };
+//   ProcessInts(phmap::MakeConstSpan(&array[0], 3));
+//
+//   // Call with a [begin, end) pair.
+//   ProcessInts(phmap::MakeConstSpan(&array[0], &array[3]));
+//
+//   // Call directly with an array.
+//   ProcessInts(phmap::MakeConstSpan(array));
+//
+//   // Call with a contiguous container.
+//   std::vector<int> some_ints = ...;
+//   ProcessInts(phmap::MakeConstSpan(some_ints));
+//   ProcessInts(phmap::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
+  return Span<const T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
+  return PHMAP_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
+  return MakeSpan(c);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
+  return Span<const T>(array, N);
+}
+}  // namespace phmap
+
+// ---------------------------------------------------------------------------
+//  layout.h
+// ---------------------------------------------------------------------------
+namespace phmap {
+namespace priv {
+
+// A type wrapper that instructs `Layout` to use the specific alignment for the
+// array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
+// and behavior as `Layout<..., T, ...>` except that the first element of the
+// array of `T` is aligned to `N` (the rest of the elements follow without
+// padding).
+//
+// Requires: `N >= alignof(T)` and `N` is a power of 2.
+template <class T, size_t N>
+struct Aligned;
+
+namespace internal_layout {
+
+template <class T>
+struct NotAligned {};
+
+template <class T, size_t N>
+struct NotAligned<const Aligned<T, N>> {
+  static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
+};
+
+template <size_t>
+using IntToSize = size_t;
+
+template <class>
+using TypeToSize = size_t;
+
+template <class T>
+struct Type : NotAligned<T> {
+    using type = T;
+};
+
+template <class T, size_t N>
+struct Type<Aligned<T, N>> {
+    using type = T;
+};
+
+template <class T>
+struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
+
+template <class T, size_t N>
+struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
+
+// Note: workaround for https://gcc.gnu.org/PR88115
+template <class T>
+struct AlignOf : NotAligned<T> {
+    static constexpr size_t value = alignof(T);
+};
+
+template <class T, size_t N>
+struct AlignOf<Aligned<T, N>> {
+    static_assert(N % alignof(T) == 0,
+                  "Custom alignment can't be lower than the type's alignment");
+    static constexpr size_t value = N;
+};
+
+// Does `Ts...` contain `T`?
+template <class T, class... Ts>
+using Contains = phmap::disjunction<std::is_same<T, Ts>...>;
+
+template <class From, class To>
+using CopyConst =
+    typename std::conditional<std::is_const<From>::value, const To, To>::type;
+
+// Note: We're not qualifying this with phmap:: because it doesn't compile under
+// MSVC.
+template <class T>
+using SliceType = Span<T>;
+
+// This namespace contains no types. It prevents functions defined in it from
+// being found by ADL.
+namespace adl_barrier {
+
+template <class Needle, class... Ts>
+constexpr size_t Find(Needle, Needle, Ts...) {
+    static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
+    return 0;
+}
+
+template <class Needle, class T, class... Ts>
+constexpr size_t Find(Needle, T, Ts...) {
+  return adl_barrier::Find(Needle(), Ts()...) + 1;
+}
+
+constexpr bool IsPow2(size_t n) { return !(n & (n - 1)); }
+
+// Returns `q * m` for the smallest `q` such that `q * m >= n`.
+// Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
+constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
+
+constexpr size_t Min(size_t a, size_t b) { return b < a ? b : a; }
+
+constexpr size_t Max(size_t a) { return a; }
+
+template <class... Ts>
+constexpr size_t Max(size_t a, size_t b, Ts... rest) {
+    return adl_barrier::Max(b < a ? a : b, rest...);
+}
+
+}  // namespace adl_barrier
+
+template <bool C>
+using EnableIf = typename std::enable_if<C, int>::type;
+
+// Can `T` be a template argument of `Layout`?
+// ---------------------------------------------------------------------------
+template <class T>
+using IsLegalElementType = std::integral_constant<
+    bool, !std::is_reference<T>::value && !std::is_volatile<T>::value &&
+              !std::is_reference<typename Type<T>::type>::value &&
+              !std::is_volatile<typename Type<T>::type>::value &&
+              adl_barrier::IsPow2(AlignOf<T>::value)>;
+
+template <class Elements, class SizeSeq, class OffsetSeq>
+class LayoutImpl;
+
+// ---------------------------------------------------------------------------
+// Public base class of `Layout` and the result type of `Layout::Partial()`.
+//
+// `Elements...` contains all template arguments of `Layout` that created this
+// instance.
+//
+// `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
+// passed to `Layout::Partial()` or `Layout::Layout()`.
+//
+// `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
+// `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
+// can compute offsets).
+// ---------------------------------------------------------------------------
+template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
+class LayoutImpl<std::tuple<Elements...>, phmap::index_sequence<SizeSeq...>,
+                 phmap::index_sequence<OffsetSeq...>> 
+{
+private:
+    static_assert(sizeof...(Elements) > 0, "At least one field is required");
+    static_assert(phmap::conjunction<IsLegalElementType<Elements>...>::value,
+                  "Invalid element type (see IsLegalElementType)");
+
+    enum {
+        NumTypes = sizeof...(Elements),
+        NumSizes = sizeof...(SizeSeq),
+        NumOffsets = sizeof...(OffsetSeq),
+    };
+
+    // These are guaranteed by `Layout`.
+    static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1),
+                  "Internal error");
+    static_assert(NumTypes > 0, "Internal error");
+
+    // Returns the index of `T` in `Elements...`. Results in a compilation error
+    // if `Elements...` doesn't contain exactly one instance of `T`.
+    template <class T>
+        static constexpr size_t ElementIndex() {
+        static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(),
+                      "Type not found");
+        return adl_barrier::Find(Type<T>(),
+                                 Type<typename Type<Elements>::type>()...);
+    }
+
+    template <size_t N>
+        using ElementAlignment =
+        AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
+
+public:
+    // Element types of all arrays packed in a tuple.
+    using ElementTypes = std::tuple<typename Type<Elements>::type...>;
+
+    // Element type of the Nth array.
+    template <size_t N>
+        using ElementType = typename std::tuple_element<N, ElementTypes>::type;
+
+    constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes)
+        : size_{sizes...} {}
+
+    // Alignment of the layout, equal to the strictest alignment of all elements.
+    // All pointers passed to the methods of layout must be aligned to this value.
+    static constexpr size_t Alignment() {
+        return adl_barrier::Max(AlignOf<Elements>::value...);
+    }
+
+    // Offset in bytes of the Nth array.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
+    //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
+    //
+    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+    template <size_t N, EnableIf<N == 0> = 0>
+        constexpr size_t Offset() const {
+        return 0;
+    }
+
+    template <size_t N, EnableIf<N != 0> = 0>
+        constexpr size_t Offset() const {
+        static_assert(N < NumOffsets, "Index out of bounds");
+        return adl_barrier::Align(
+            Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
+            ElementAlignment<N>::value);
+    }
+
+    // Offset in bytes of the array with the specified element type. There must
+    // be exactly one such array and its zero-based index must be at most
+    // `NumSizes`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
+    //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
+    template <class T>
+        constexpr size_t Offset() const {
+        return Offset<ElementIndex<T>()>();
+    }
+
+    // Offsets in bytes of all arrays for which the offsets are known.
+    constexpr std::array<size_t, NumOffsets> Offsets() const {
+        return {{Offset<OffsetSeq>()...}};
+    }
+
+    // The number of elements in the Nth array. This is the Nth argument of
+    // `Layout::Partial()` or `Layout::Layout()` (zero-based).
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Size<0>() == 3);
+    //   assert(x.Size<1>() == 4);
+    //
+    // Requires: `N < NumSizes`.
+    template <size_t N>
+        constexpr size_t Size() const {
+        static_assert(N < NumSizes, "Index out of bounds");
+        return size_[N];
+    }
+
+    // The number of elements in the array with the specified element type.
+    // There must be exactly one such array and its zero-based index must be
+    // at most `NumSizes`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Size<int>() == 3);
+    //   assert(x.Size<double>() == 4);
+    template <class T>
+        constexpr size_t Size() const {
+        return Size<ElementIndex<T>()>();
+    }
+
+    // The number of elements of all arrays for which they are known.
+    constexpr std::array<size_t, NumSizes> Sizes() const {
+        return {{Size<SizeSeq>()...}};
+    }
+
+    // Pointer to the beginning of the Nth array.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   int* ints = x.Pointer<0>(p);
+    //   double* doubles = x.Pointer<1>(p);
+    //
+    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+    // Requires: `p` is aligned to `Alignment()`.
+    template <size_t N, class Char>
+        CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
+        using C = typename std::remove_const<Char>::type;
+        static_assert(
+            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
+            std::is_same<C, signed char>(),
+            "The argument must be a pointer to [const] [signed|unsigned] char");
+        constexpr size_t alignment = Alignment();
+        (void)alignment;
+        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
+        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
+    }
+
+    // Pointer to the beginning of the array with the specified element type.
+    // There must be exactly one such array and its zero-based index must be at
+    // most `NumSizes`.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   int* ints = x.Pointer<int>(p);
+    //   double* doubles = x.Pointer<double>(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class T, class Char>
+        CopyConst<Char, T>* Pointer(Char* p) const {
+        return Pointer<ElementIndex<T>()>(p);
+    }
+
+    // Pointers to all arrays for which pointers are known.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //
+    //   int* ints;
+    //   double* doubles;
+    //   std::tie(ints, doubles) = x.Pointers(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    //
+    // Note: We're not using ElementType alias here because it does not compile
+    // under MSVC.
+    template <class Char>
+        std::tuple<CopyConst<
+                       Char, typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
+        Pointers(Char* p) const {
+        return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
+            Pointer<OffsetSeq>(p)...);
+    }
+
+    // The Nth array.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   Span<int> ints = x.Slice<0>(p);
+    //   Span<double> doubles = x.Slice<1>(p);
+    //
+    // Requires: `N < NumSizes`.
+    // Requires: `p` is aligned to `Alignment()`.
+    template <size_t N, class Char>
+        SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const {
+        return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
+    }
+
+    // The array with the specified element type. There must be exactly one
+    // such array and its zero-based index must be less than `NumSizes`.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   Span<int> ints = x.Slice<int>(p);
+    //   Span<double> doubles = x.Slice<double>(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class T, class Char>
+        SliceType<CopyConst<Char, T>> Slice(Char* p) const {
+        return Slice<ElementIndex<T>()>(p);
+    }
+
+    // All arrays with known sizes.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //
+    //   Span<int> ints;
+    //   Span<double> doubles;
+    //   std::tie(ints, doubles) = x.Slices(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    //
+    // Note: We're not using ElementType alias here because it does not compile
+    // under MSVC.
+    template <class Char>
+        std::tuple<SliceType<CopyConst<
+                                 Char, typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
+        Slices(Char* p) const {
+        // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
+        // in 6.1).
+        (void)p;
+        return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
+            Slice<SizeSeq>(p)...);
+    }
+
+    // The size of the allocation that fits all arrays.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
+    //
+    // Requires: `NumSizes == sizeof...(Ts)`.
+    constexpr size_t AllocSize() const {
+        static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
+        return Offset<NumTypes - 1>() +
+            SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
+    }
+
+    // If built with --config=asan, poisons padding bytes (if any) in the
+    // allocation. The pointer must point to a memory block at least
+    // `AllocSize()` bytes in length.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
+        void PoisonPadding(const Char* p) const {
+        Pointer<0>(p);  // verify the requirements on `Char` and `p`
+    }
+
+    template <class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
+        void PoisonPadding(const Char* p) const {
+        static_assert(N < NumOffsets, "Index out of bounds");
+        (void)p;
+#ifdef ADDRESS_SANITIZER
+        PoisonPadding<Char, N - 1>(p);
+        // The `if` is an optimization. It doesn't affect the observable behaviour.
+        if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
+            size_t start =
+                Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1];
+            ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
+        }
+#endif
+    }
+
+private:
+    // Arguments of `Layout::Partial()` or `Layout::Layout()`.
+    size_t size_[NumSizes > 0 ? NumSizes : 1];
+};
+
+template <size_t NumSizes, class... Ts>
+using LayoutType = LayoutImpl<
+    std::tuple<Ts...>, phmap::make_index_sequence<NumSizes>,
+    phmap::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
+
+}  // namespace internal_layout
+
+// ---------------------------------------------------------------------------
+// Descriptor of arrays of various types and sizes laid out in memory one after
+// another. See the top of the file for documentation.
+//
+// Check out the public API of internal_layout::LayoutImpl above. The type is
+// internal to the library but its methods are public, and they are inherited
+// by `Layout`.
+// ---------------------------------------------------------------------------
+template <class... Ts>
+class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> 
+{
+public:
+    static_assert(sizeof...(Ts) > 0, "At least one field is required");
+    static_assert(
+        phmap::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
+        "Invalid element type (see IsLegalElementType)");
+
+    template <size_t NumSizes>
+    using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
+
+    template <class... Sizes>
+    static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) {
+        static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
+        return PartialType<sizeof...(Sizes)>(phmap::forward<Sizes>(sizes)...);
+    }
+
+    // Creates a layout with the sizes of all arrays specified. If you know
+    // only the sizes of the first N arrays (where N can be zero), you can use
+    // `Partial()` defined above. The constructor is essentially equivalent to
+    // calling `Partial()` and passing in all array sizes; the constructor is
+    // provided as a convenient abbreviation.
+    //
+    // Note: The sizes of the arrays must be specified in number of elements,
+    // not in bytes.
+    constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes)
+        : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+// ---------------------------------------------------------------------------
+//  compressed_tuple.h
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    // We need to mark these classes with this declspec to ensure that
+    // CompressedTuple happens.
+    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
+#else  // _MSC_VER
+    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#endif  // _MSC_VER
+
+namespace phmap {
+namespace priv {
+
+template <typename... Ts>
+class CompressedTuple;
+
+namespace internal_compressed_tuple {
+
+template <typename D, size_t I>
+struct Elem;
+template <typename... B, size_t I>
+struct Elem<CompressedTuple<B...>, I>
+    : std::tuple_element<I, std::tuple<B...>> {};
+template <typename D, size_t I>
+using ElemT = typename Elem<D, I>::type;
+
+// ---------------------------------------------------------------------------
+// Use the __is_final intrinsic if available. Where it's not available, classes
+// declared with the 'final' specifier cannot be used as CompressedTuple
+// elements.
+// TODO(sbenza): Replace this with std::is_final in C++14.
+// ---------------------------------------------------------------------------
+template <typename T>
+constexpr bool IsFinal() {
+#if defined(__clang__) || defined(__GNUC__)
+    return __is_final(T);
+#else
+    return false;
+#endif
+}
+
+template <typename T>
+constexpr bool ShouldUseBase() {
+#ifdef __INTEL_COMPILER
+    // avoid crash in Intel compiler
+    // assertion failed at: "shared/cfe/edgcpfe/lower_init.c", line 7013
+    return false; 
+#else
+    return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
+#endif
+}
+
+// The storage class provides two specializations:
+//  - For empty classes, it stores T as a base class.
+//  - For everything else, it stores T as a member.
+// ------------------------------------------------
+template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
+struct Storage 
+{
+    using T = ElemT<D, I>;
+    T value;
+    constexpr Storage() = default;
+    explicit constexpr Storage(T&& v) : value(phmap::forward<T>(v)) {}
+    constexpr const T& get() const& { return value; }
+    T& get() & { return value; }
+    constexpr const T&& get() const&& { return phmap::move(*this).value; }
+    T&& get() && { return std::move(*this).value; }
+};
+
+template <typename D, size_t I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
+    : ElemT<D, I> 
+{
+    using T = internal_compressed_tuple::ElemT<D, I>;
+    constexpr Storage() = default;
+    explicit constexpr Storage(T&& v) : T(phmap::forward<T>(v)) {}
+    constexpr const T& get() const& { return *this; }
+    T& get() & { return *this; }
+    constexpr const T&& get() const&& { return phmap::move(*this); }
+    T&& get() && { return std::move(*this); }
+};
+
+template <typename D, typename I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+
+template <typename... Ts, size_t... I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+    CompressedTupleImpl<CompressedTuple<Ts...>, phmap::index_sequence<I...>>
+    // We use the dummy identity function through std::integral_constant to
+    // convince MSVC of accepting and expanding I in that context. Without it
+    // you would get:
+    //   error C3548: 'I': parameter pack cannot be used in this context
+    : Storage<CompressedTuple<Ts...>,
+              std::integral_constant<size_t, I>::value>... 
+{
+    constexpr CompressedTupleImpl() = default;
+    explicit constexpr CompressedTupleImpl(Ts&&... args)
+        : Storage<CompressedTuple<Ts...>, I>(phmap::forward<Ts>(args))... {}
+};
+
+}  // namespace internal_compressed_tuple
+
+// ---------------------------------------------------------------------------
+// Helper class to perform the Empty Base Class Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the CompressedTuple. If all types in Ts are
+// empty classes, then CompressedTuple<Ts...> is itself an empty class.
+//
+// To access the members, use member .get<N>() function.
+//
+// Eg:
+//   phmap::priv::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// https://en.cppreference.com/w/cpp/language/ebo
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+    : private internal_compressed_tuple::CompressedTupleImpl<
+          CompressedTuple<Ts...>, phmap::index_sequence_for<Ts...>> 
+{
+private:
+    template <int I>
+        using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+
+public:
+    constexpr CompressedTuple() = default;
+    explicit constexpr CompressedTuple(Ts... base)
+        : CompressedTuple::CompressedTupleImpl(phmap::forward<Ts>(base)...) {}
+
+    template <int I>
+        ElemT<I>& get() & {
+        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        constexpr const ElemT<I>& get() const& {
+        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        ElemT<I>&& get() && {
+        return std::move(*this)
+            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        constexpr const ElemT<I>&& get() const&& {
+        return phmap::move(*this)
+            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+    }
+};
+
+// Explicit specialization for a zero-element tuple
+// (needed to avoid ambiguous overloads for the default constructor).
+// ---------------------------------------------------------------------------
+template <>
+class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
+
+}  // namespace priv
+}  // namespace phmap
+
+
+namespace phmap {
+namespace priv {
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    // warning warning C4324: structure was padded due to alignment specifier
+    #pragma warning(disable : 4324)
+#endif
+
+
+// ----------------------------------------------------------------------------
+// Allocates at least n bytes aligned to the specified alignment.
+// Alignment must be a power of 2. It must be positive.
+//
+// Note that many allocators don't honor alignment requirements above certain
+// threshold (usually either alignof(std::max_align_t) or alignof(void*)).
+// Allocate() doesn't apply alignment corrections. If the underlying allocator
+// returns insufficiently alignment pointer, that's what you are going to get.
+// ----------------------------------------------------------------------------
+template <size_t Alignment, class Alloc>
+void* Allocate(Alloc* alloc, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  struct alignas(Alignment) M {};
+  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
+  A mem_alloc(*alloc);
+  void* p = AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
+  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
+         "allocator does not respect alignment");
+  return p;
+}
+
+// ----------------------------------------------------------------------------
+// The pointer must have been previously obtained by calling
+// Allocate<Alignment>(alloc, n).
+// ----------------------------------------------------------------------------
+template <size_t Alignment, class Alloc>
+void Deallocate(Alloc* alloc, void* p, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  struct alignas(Alignment) M {};
+  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
+  A mem_alloc(*alloc);
+  AT::deallocate(mem_alloc, static_cast<M*>(p),
+                 (n + sizeof(M) - 1) / sizeof(M));
+}
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+// Helper functions for asan and msan.
+// ----------------------------------------------------------------------------
+inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ADDRESS_SANITIZER
+    ASAN_POISON_MEMORY_REGION(m, s);
+#endif
+#ifdef MEMORY_SANITIZER
+    __msan_poison(m, s);
+#endif
+    (void)m;
+    (void)s;
+}
+
+inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ADDRESS_SANITIZER
+    ASAN_UNPOISON_MEMORY_REGION(m, s);
+#endif
+#ifdef MEMORY_SANITIZER
+    __msan_unpoison(m, s);
+#endif
+    (void)m;
+    (void)s;
+}
+
+template <typename T>
+inline void SanitizerPoisonObject(const T* object) {
+    SanitizerPoisonMemoryRegion(object, sizeof(T));
+}
+
+template <typename T>
+inline void SanitizerUnpoisonObject(const T* object) {
+    SanitizerUnpoisonMemoryRegion(object, sizeof(T));
+}
+
+}  // namespace priv
+}  // namespace phmap
+
+
+// ---------------------------------------------------------------------------
+//  thread_annotations.h
+// ---------------------------------------------------------------------------
+
+#if defined(__clang__)
+    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+#define PHMAP_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+#define PHMAP_PT_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define PHMAP_ACQUIRED_AFTER(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define PHMAP_ACQUIRED_BEFORE(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define PHMAP_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+#define PHMAP_SHARED_LOCKS_REQUIRED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+#define PHMAP_LOCKS_EXCLUDED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define PHMAP_LOCK_RETURNED(x) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define PHMAP_LOCKABLE \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+#define PHMAP_SCOPED_LOCKABLE \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define PHMAP_EXCLUSIVE_LOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+#define PHMAP_SHARED_LOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+#define PHMAP_UNLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+#define PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+#define PHMAP_SHARED_TRYLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+#define PHMAP_ASSERT_EXCLUSIVE_LOCK(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+#define PHMAP_ASSERT_SHARED_LOCK(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+#define PHMAP_NO_THREAD_SAFETY_ANALYSIS \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// TS_UNCHECKED should be placed around lock expressions that are not valid
+// C++ syntax, but which are present for documentation purposes.  These
+// annotations will be ignored by the analysis.
+#define PHMAP_TS_UNCHECKED(x) ""
+
+// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to TS_UNCHECKED.
+#define PHMAP_TS_FIXME(x) ""
+
+// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
+// a particular function.  However, this attribute is used to mark functions
+// that are incorrect and need to be fixed.  It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME  PHMAP_NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
+// annotation that needs to be fixed, because it is producing thread safety
+// warning.  It disables the GUARDED_BY.
+#define PHMAP_GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation.  This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define PHMAP_TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
+
+
+namespace phmap {
+namespace thread_safety_analysis {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
+    return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
+    return v;
+}
+
+}  // namespace thread_safety_analysis
+
+namespace priv {
+
+namespace memory_internal {
+
+// ----------------------------------------------------------------------------
+// If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
+// OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
+// offsetof(Pair, second) respectively. Otherwise they are -1.
+//
+// The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
+// type, which is non-portable.
+// ----------------------------------------------------------------------------
+template <class Pair, class = std::true_type>
+struct OffsetOf {
+    static constexpr size_t kFirst = (size_t)-1;
+  static constexpr size_t kSecond = (size_t)-1;
+};
+
+template <class Pair>
+struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type> 
+{
+    static constexpr size_t kFirst = offsetof(Pair, first);
+    static constexpr size_t kSecond = offsetof(Pair, second);
+};
+
+// ----------------------------------------------------------------------------
+template <class K, class V>
+struct IsLayoutCompatible 
+{
+private:
+    struct Pair {
+        K first;
+        V second;
+    };
+
+    // Is P layout-compatible with Pair?
+    template <class P>
+    static constexpr bool LayoutCompatible() {
+        return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
+            alignof(P) == alignof(Pair) &&
+            memory_internal::OffsetOf<P>::kFirst ==
+            memory_internal::OffsetOf<Pair>::kFirst &&
+            memory_internal::OffsetOf<P>::kSecond ==
+            memory_internal::OffsetOf<Pair>::kSecond;
+    }
+
+public:
+    // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
+    // then it is safe to store them in a union and read from either.
+    static constexpr bool value = std::is_standard_layout<K>() &&
+        std::is_standard_layout<Pair>() &&
+        memory_internal::OffsetOf<Pair>::kFirst == 0 &&
+        LayoutCompatible<std::pair<K, V>>() &&
+        LayoutCompatible<std::pair<const K, V>>();
+};
+
+}  // namespace memory_internal
+
+// ----------------------------------------------------------------------------
+// The internal storage type for key-value containers like flat_hash_map.
+//
+// It is convenient for the value_type of a flat_hash_map<K, V> to be
+// pair<const K, V>; the "const K" prevents accidental modification of the key
+// when dealing with the reference returned from find() and similar methods.
+// However, this creates other problems; we want to be able to emplace(K, V)
+// efficiently with move operations, and similarly be able to move a
+// pair<K, V> in insert().
+//
+// The solution is this union, which aliases the const and non-const versions
+// of the pair. This also allows flat_hash_map<const K, V> to work, even though
+// that has the same efficiency issues with move in emplace() and insert() -
+// but people do it anyway.
+//
+// If kMutableKeys is false, only the value member can be accessed.
+//
+// If kMutableKeys is true, key can be accessed through all slots while value
+// and mutable_value must be accessed only via INITIALIZED slots. Slots are
+// created and destroyed via mutable_value so that the key can be moved later.
+//
+// Accessing one of the union fields while the other is active is safe as
+// long as they are layout-compatible, which is guaranteed by the definition of
+// kMutableKeys. For C++11, the relevant section of the standard is
+// https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
+// ----------------------------------------------------------------------------
+template <class K, class V>
+union map_slot_type 
+{
+    map_slot_type() {}
+    ~map_slot_type() = delete;
+    map_slot_type(const map_slot_type&) = delete;
+    map_slot_type& operator=(const map_slot_type&) = delete;
+
+    using value_type = std::pair<const K, V>;
+    using mutable_value_type = std::pair<K, V>;
+
+    value_type value;
+    mutable_value_type mutable_value;
+    K key;
+};
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+template <class K, class V>
+struct map_slot_policy 
+{
+    using slot_type = map_slot_type<K, V>;
+    using value_type = std::pair<const K, V>;
+    using mutable_value_type = std::pair<K, V>;
+
+private:
+    static void emplace(slot_type* slot) {
+        // The construction of union doesn't do anything at runtime but it allows us
+        // to access its members without violating aliasing rules.
+        new (slot) slot_type;
+    }
+    // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
+    // or the other via slot_type. We are also free to access the key via
+    // slot_type::key in this case.
+    using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
+
+public:
+    static value_type& element(slot_type* slot) { return slot->value; }
+    static const value_type& element(const slot_type* slot) {
+        return slot->value;
+    }
+
+    static const K& key(const slot_type* slot) {
+        return kMutableKeys::value ? slot->key : slot->value.first;
+    }
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        emplace(slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
+                                                         std::forward<Args>(args)...);
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                         std::forward<Args>(args)...);
+        }
+    }
+
+    // Construct this slot by moving from another slot.
+    template <class Allocator>
+    static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
+        emplace(slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(
+                *alloc, &slot->mutable_value, std::move(other->mutable_value));
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                         std::move(other->value));
+        }
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
+        } else {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
+        }
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        emplace(new_slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(
+                *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
+                                                         std::move(old_slot->value));
+        }
+        destroy(alloc, old_slot);
+    }
+
+    template <class Allocator>
+    static void swap(Allocator* alloc, slot_type* a, slot_type* b) {
+        if (kMutableKeys::value) {
+            using std::swap;
+            swap(a->mutable_value, b->mutable_value);
+        } else {
+            value_type tmp = std::move(a->value);
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &a->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &a->value,
+                                                         std::move(b->value));
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &b->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &b->value,
+                                                         std::move(tmp));
+        }
+    }
+
+    template <class Allocator>
+    static void move(Allocator* alloc, slot_type* src, slot_type* dest) {
+        if (kMutableKeys::value) {
+            dest->mutable_value = std::move(src->mutable_value);
+        } else {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &dest->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &dest->value,
+                                                          std::move(src->value));
+        }
+    }
+
+    template <class Allocator>
+    static void move(Allocator* alloc, slot_type* first, slot_type* last,
+                     slot_type* result) {
+        for (slot_type *src = first, *dest = result; src != last; ++src, ++dest)
+            move(alloc, src, dest);
+    }
+};
+
+}  // namespace priv
+}  // phmap
+
+
+namespace phmap {
+
+#ifdef BOOST_THREAD_LOCK_OPTIONS_HPP
+    using defer_lock_t  = boost::defer_lock_t;
+    using try_to_lock_t = boost::try_to_lock_t;
+    using adopt_lock_t  = boost::adopt_lock_t;
+#else
+    struct adopt_lock_t  { explicit adopt_lock_t() = default; };
+    struct defer_lock_t  { explicit defer_lock_t() = default; };
+    struct try_to_lock_t { explicit try_to_lock_t() = default; };
+#endif
+
+// -----------------------------------------------------------------------------
+// NullMutex
+// -----------------------------------------------------------------------------
+// A class that implements the Mutex interface, but does nothing. This is to be 
+// used as a default template parameters for classes who provide optional 
+// internal locking (like phmap::parallel_flat_hash_map).
+// -----------------------------------------------------------------------------
+class NullMutex {
+public:
+    NullMutex() {}
+    ~NullMutex() {}
+    void lock() {}
+    void unlock() {}
+    bool try_lock() { return true; }
+    void lock_shared() {}
+    void unlock_shared() {}
+    bool try_lock_shared() { return true; }
+};
+
+// ------------------------ lockable object used internally -------------------------
+template <class MutexType>
+class LockableBaseImpl 
+{
+public:
+    // ----------------------------------------------------
+    struct DoNothing
+    {
+        using mutex_type = MutexType;  
+        DoNothing() noexcept {}
+        explicit DoNothing(mutex_type& ) noexcept {}
+        explicit DoNothing(mutex_type& , mutex_type&) noexcept {}
+        DoNothing(mutex_type&, phmap::adopt_lock_t) noexcept {}
+        DoNothing(mutex_type&, phmap::defer_lock_t) noexcept {}
+        DoNothing(mutex_type&, phmap::try_to_lock_t) {}
+        template<class T> explicit DoNothing(T&&) {}
+        DoNothing& operator=(const DoNothing&) { return *this; }
+        DoNothing& operator=(DoNothing&&) { return *this; }
+        void swap(DoNothing &) {}
+        bool owns_lock() const noexcept { return true; }
+    };
+
+    // ----------------------------------------------------
+    class WriteLock
+    {
+    public:
+        using mutex_type = MutexType;
+
+        WriteLock() :  m_(nullptr), locked_(false)  {}
+
+        explicit WriteLock(mutex_type &m) : m_(&m) { 
+            m_->lock(); 
+            locked_ = true; 
+        }
+
+        WriteLock(mutex_type& m, adopt_lock_t) noexcept :
+            m_(&m), locked_(true) 
+        {}
+
+        WriteLock(mutex_type& m, defer_lock_t) noexcept :
+            m_(&m), locked_(false) 
+        {}
+
+        WriteLock(mutex_type& m, try_to_lock_t)  :
+            m_(&m), locked_(false) { 
+            m_->try_lock(); 
+        }
+
+        WriteLock(WriteLock &&o) :
+            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
+            o.locked_ = false;
+            o.m_      = nullptr;
+        }
+
+        WriteLock& operator=(WriteLock&& other) {
+            WriteLock temp(std::move(other));
+            swap(temp);
+            return *this;
+        }
+
+        ~WriteLock() {
+            if (locked_) 
+                m_->unlock(); 
+        }
+
+        void lock() { 
+            if (!locked_) { 
+                m_->lock(); 
+                locked_ = true; 
+            }
+        }
+
+        void unlock() { 
+            if (locked_) {
+                m_->unlock(); 
+                locked_ = false;
+            }
+        } 
+
+        bool try_lock() { 
+            if (locked_)
+                return true;
+            locked_ = m_->try_lock(); 
+            return locked_;
+        }
+        
+        bool owns_lock() const noexcept { return locked_; }
+
+        void swap(WriteLock &o) noexcept { 
+            std::swap(m_, o.m_);
+            std::swap(locked_, o.locked_);
+        }
+
+        mutex_type *mutex() const noexcept { return m_; }
+
+    private:
+        mutex_type *m_;
+        bool        locked_;
+    };
+
+    // ----------------------------------------------------
+    class ReadLock
+    {
+    public:
+        using mutex_type = MutexType;
+
+        ReadLock() :  m_(nullptr), locked_(false)  {}
+
+        explicit ReadLock(mutex_type &m) : m_(&m) { 
+            m_->lock_shared(); 
+            locked_ = true; 
+        }
+
+        ReadLock(mutex_type& m, adopt_lock_t) noexcept :
+            m_(&m), locked_(true) 
+        {}
+
+        ReadLock(mutex_type& m, defer_lock_t) noexcept :
+            m_(&m), locked_(false) 
+        {}
+
+        ReadLock(mutex_type& m, try_to_lock_t)  :
+            m_(&m), locked_(false) { 
+            m_->try_lock_shared(); 
+        }
+
+        ReadLock(ReadLock &&o) :
+            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
+            o.locked_ = false;
+            o.m_      = nullptr;
+        }
+
+        ReadLock& operator=(ReadLock&& other) {
+            ReadLock temp(std::move(other));
+            swap(temp);
+            return *this;
+        }
+
+        ~ReadLock() {
+            if (locked_) 
+                m_->unlock_shared(); 
+        }
+
+        void lock() { 
+            if (!locked_) { 
+                m_->lock_shared(); 
+                locked_ = true; 
+            }
+        }
+
+        void unlock() { 
+            if (locked_) {
+                m_->unlock_shared(); 
+                locked_ = false;
+            }
+        } 
+
+        bool try_lock() { 
+            if (locked_)
+                return true;
+            locked_ = m_->try_lock_shared(); 
+            return locked_;
+        }
+        
+        bool owns_lock() const noexcept { return locked_; }
+
+        void swap(ReadLock &o) noexcept { 
+            std::swap(m_, o.m_);
+            std::swap(locked_, o.locked_);
+        }
+
+        mutex_type *mutex() const noexcept { return m_; }
+
+    private:
+        mutex_type *m_;
+        bool        locked_;
+    };
+
+    // ----------------------------------------------------
+    class WriteLocks
+    {
+    public:
+        using mutex_type = MutexType;  
+
+        explicit WriteLocks(mutex_type& m1, mutex_type& m2) : 
+            _m1(m1), _m2(m2)
+        { 
+            std::lock(m1, m2); 
+        }
+
+        WriteLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
+            _m1(m1), _m2(m2)
+        { // adopt means we already own the mutexes
+        }
+
+        ~WriteLocks()
+        {
+            _m1.unlock();
+            _m2.unlock();
+        }
+
+        WriteLocks(WriteLocks const&) = delete;
+        WriteLocks& operator=(WriteLocks const&) = delete;
+    private:
+        mutex_type& _m1;
+        mutex_type& _m2;
+    };
+
+    // ----------------------------------------------------
+    class ReadLocks
+    {
+    public:
+        using mutex_type = MutexType;  
+
+        explicit ReadLocks(mutex_type& m1, mutex_type& m2) : 
+            _m1(m1), _m2(m2)
+        { 
+            _m1.lock_shared(); 
+            _m2.lock_shared(); 
+        }
+
+        ReadLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
+            _m1(m1), _m2(m2)
+        { // adopt means we already own the mutexes
+        }
+
+        ~ReadLocks()
+        {
+            _m1.unlock_shared();
+            _m2.unlock_shared();
+        }
+
+        ReadLocks(ReadLocks const&) = delete;
+        ReadLocks& operator=(ReadLocks const&) = delete;
+    private:
+        mutex_type& _m1;
+        mutex_type& _m2;
+    };
+};
+
+// ------------------------ holds a mutex ------------------------------------
+// Default implementation for Lockable, should work fine for std::mutex 
+// -----------------------------------
+// use as:
+//    using Lockable = phmap::LockableImpl<mutex_type>;
+//    Lockable m;
+//  
+//    Lockable::UpgradeLock read_lock(m); // take a upgradable lock
+//
+//    {
+//        Lockable::UpgradeToUnique unique_lock(read_lock);
+//        // now locked for write
+//    }
+//
+// ---------------------------------------------------------------------------
+//         Generic mutex support (always write locks)
+// --------------------------------------------------------------------------
+template <class Mtx_>
+class LockableImpl : public Mtx_
+{
+public:
+    using mutex_type      = Mtx_;
+    using Base            = LockableBaseImpl<Mtx_>;
+    using SharedLock      = typename Base::WriteLock;
+    using UpgradeLock     = typename Base::WriteLock;
+    using UniqueLock      = typename Base::WriteLock;
+    using SharedLocks     = typename Base::WriteLocks;
+    using UniqueLocks     = typename Base::WriteLocks;
+    using UpgradeToUnique = typename Base::DoNothing;        // we already have unique ownership
+};
+
+// ---------------------------------------------------------------------------
+//          Null mutex (no-op) - when we don't want internal synchronization
+// ---------------------------------------------------------------------------
+template <>
+class  LockableImpl<phmap::NullMutex>: public phmap::NullMutex
+{
+public:
+    using mutex_type      = phmap::NullMutex;
+    using Base            = LockableBaseImpl<phmap::NullMutex>;
+    using SharedLock      = typename Base::DoNothing; 
+    using UpgradeLock     = typename Base::DoNothing; 
+    using UniqueLock      = typename Base::DoNothing; 
+    using UpgradeToUnique = typename Base::DoNothing; 
+    using SharedLocks     = typename Base::DoNothing;
+    using UniqueLocks     = typename Base::DoNothing;
+};
+
+// --------------------------------------------------------------------------
+//         Abseil Mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef ABSL_SYNCHRONIZATION_MUTEX_H_
+    
+    struct AbslMutex : protected absl::Mutex
+    {
+        void lock()            { this->Lock(); }
+        void unlock()          { this->Unlock(); }
+        void try_lock()        { this->TryLock(); }
+        void lock_shared()     { this->ReaderLock(); }
+        void unlock_shared()   { this->ReaderUnlock(); }
+        void try_lock_shared() { this->ReaderTryLock(); }
+    };
+    
+    template <>
+    class  LockableImpl<absl::Mutex> : public AbslMutex
+    {
+    public:
+        using mutex_type      = phmap::AbslMutex;
+        using Base            = LockableBaseImpl<phmap::AbslMutex>;
+        using SharedLock      = typename Base::ReadLock;
+        using UpgradeLock     = typename Base::WriteLock;
+        using UniqueLock      = typename Base::WriteLock;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing; // we already have unique ownership
+    };
+
+#endif
+
+// --------------------------------------------------------------------------
+//         Boost shared_mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef BOOST_THREAD_SHARED_MUTEX_HPP
+
+#if 1
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<boost::shared_mutex> : public boost::shared_mutex
+    {
+    public:
+        using mutex_type      = boost::shared_mutex;
+        using Base            = LockableBaseImpl<boost::shared_mutex>;
+        using SharedLock      = boost::shared_lock<mutex_type>;
+        using UpgradeLock     = boost::unique_lock<mutex_type>; // assume can't upgrade
+        using UniqueLock      = boost::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
+    };
+#else
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<boost::upgrade_mutex> : public boost::upgrade_mutex
+    {
+    public:
+        using mutex_type      = boost::upgrade_mutex;
+        using SharedLock      = boost::shared_lock<mutex_type>;
+        using UpgradeLock     = boost::upgrade_lock<mutex_type>;
+        using UniqueLock      = boost::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = boost::upgrade_to_unique_lock<mutex_type>;
+    };
+#endif
+
+#endif // BOOST_THREAD_SHARED_MUTEX_HPP
+
+// --------------------------------------------------------------------------
+//         std::shared_mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_SHARED_MUTEX
+
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<std::shared_mutex> : public std::shared_mutex
+    {
+    public:
+        using mutex_type      = std::shared_mutex;
+        using Base            = LockableBaseImpl<std::shared_mutex>;
+        using SharedLock      = std::shared_lock<mutex_type>;
+        using UpgradeLock     = std::unique_lock<mutex_type>; // assume can't upgrade
+        using UniqueLock      = std::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
+    };
+#endif // PHMAP_HAVE_SHARED_MUTEX
+
+
+}  // phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif // phmap_base_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_bits.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_bits.h
new file mode 100644
index 00000000..d37ede35
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_bits.h
@@ -0,0 +1,664 @@
+#if !defined(phmap_bits_h_guard_)
+#define phmap_bits_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+// The following guarantees declaration of the byte swap functions
+#ifdef _MSC_VER
+    #include <stdlib.h>  // NOLINT(build/include)
+#elif defined(__APPLE__)
+    // Mac OS X / Darwin features
+    #include <libkern/OSByteOrder.h>
+#elif defined(__FreeBSD__)
+    #include <sys/endian.h>
+#elif defined(__GLIBC__)
+    #include <byteswap.h>  // IWYU pragma: export
+#endif
+
+#include <string.h>
+#include <cstdint>
+#include "phmap_config.h"
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+#endif
+
+// -----------------------------------------------------------------------------
+// unaligned APIs
+// -----------------------------------------------------------------------------
+// Portable handling of unaligned loads, stores, and copies.
+// On some platforms, like ARM, the copy functions can be more efficient
+// then a load and a store.
+// -----------------------------------------------------------------------------
+
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+    defined(MEMORY_SANITIZER)
+#include <stdint.h>
+
+extern "C" {
+    uint16_t __sanitizer_unaligned_load16(const void *p);
+    uint32_t __sanitizer_unaligned_load32(const void *p);
+    uint64_t __sanitizer_unaligned_load64(const void *p);
+    void __sanitizer_unaligned_store16(void *p, uint16_t v);
+    void __sanitizer_unaligned_store32(void *p, uint32_t v);
+    void __sanitizer_unaligned_store64(void *p, uint64_t v);
+}  // extern "C"
+
+namespace phmap {
+namespace bits {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  return __sanitizer_unaligned_load16(p);
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  return __sanitizer_unaligned_load32(p);
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  return __sanitizer_unaligned_load64(p);
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) {
+  __sanitizer_unaligned_store16(p, v);
+}
+
+inline void UnalignedStore32(void *p, uint32_t v) {
+  __sanitizer_unaligned_store32(p, v);
+}
+
+inline void UnalignedStore64(void *p, uint64_t v) {
+  __sanitizer_unaligned_store64(p, v);
+}
+
+}  // namespace bits
+}  // namespace phmap
+
+#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
+
+#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
+
+#else
+
+namespace phmap {
+namespace bits {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  uint16_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  uint32_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  uint64_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+}  // namespace bits
+}  // namespace phmap
+
+#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
+
+#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
+
+#endif
+
+// -----------------------------------------------------------------------------
+// File: optimization.h
+// -----------------------------------------------------------------------------
+
+#if defined(__pnacl__)
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#elif defined(__clang__)
+    // Clang will not tail call given inline volatile assembly.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(__GNUC__)
+    // GCC will not tail call given inline volatile assembly.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(_MSC_VER)
+    #include <intrin.h>
+    // The __nop() intrinsic blocks the optimisation.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
+#else
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#endif
+
+#if defined(__GNUC__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+#ifdef PHMAP_HAVE_INTRINSIC_INT128
+    __extension__ typedef unsigned __int128 phmap_uint128;
+    inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high) 
+    {
+        auto result = static_cast<phmap_uint128>(a) * static_cast<phmap_uint128>(b);
+        *high = static_cast<uint64_t>(result >> 64);
+        return static_cast<uint64_t>(result);
+    }
+    #define PHMAP_HAS_UMUL128 1
+#elif (defined(_MSC_VER))
+    #if defined(_M_X64)
+        #pragma intrinsic(_umul128)
+        inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high) 
+        {
+            return _umul128(a, b, high);
+        }
+        #define PHMAP_HAS_UMUL128 1
+    #endif
+#endif
+
+#if defined(__GNUC__)
+    #pragma GCC diagnostic pop
+#endif
+
+#if defined(__GNUC__)
+    // Cache line alignment
+    #if defined(__i386__) || defined(__x86_64__)
+        #define PHMAP_CACHELINE_SIZE 64
+    #elif defined(__powerpc64__)
+        #define PHMAP_CACHELINE_SIZE 128
+    #elif defined(__aarch64__)
+        // We would need to read special register ctr_el0 to find out L1 dcache size.
+        // This value is a good estimate based on a real aarch64 machine.
+        #define PHMAP_CACHELINE_SIZE 64
+    #elif defined(__arm__)
+        // Cache line sizes for ARM: These values are not strictly correct since
+        // cache line sizes depend on implementations, not architectures.  There
+        // are even implementations with cache line sizes configurable at boot
+        // time.
+        #if defined(__ARM_ARCH_5T__)
+            #define PHMAP_CACHELINE_SIZE 32
+        #elif defined(__ARM_ARCH_7A__)
+            #define PHMAP_CACHELINE_SIZE 64
+        #endif
+    #endif
+
+    #ifndef PHMAP_CACHELINE_SIZE
+        // A reasonable default guess.  Note that overestimates tend to waste more
+        // space, while underestimates tend to waste more time.
+        #define PHMAP_CACHELINE_SIZE 64
+    #endif
+
+    #define PHMAP_CACHELINE_ALIGNED __attribute__((aligned(PHMAP_CACHELINE_SIZE)))
+#elif defined(_MSC_VER)
+    #define PHMAP_CACHELINE_SIZE 64
+    #define PHMAP_CACHELINE_ALIGNED __declspec(align(PHMAP_CACHELINE_SIZE))
+#else
+    #define PHMAP_CACHELINE_SIZE 64
+    #define PHMAP_CACHELINE_ALIGNED
+#endif
+
+
+#if PHMAP_HAVE_BUILTIN(__builtin_expect) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+    #define PHMAP_PREDICT_FALSE(x) (x)
+    #define PHMAP_PREDICT_TRUE(x) (x)
+#endif
+
+// -----------------------------------------------------------------------------
+// File: bits.h
+// -----------------------------------------------------------------------------
+
+#if defined(_MSC_VER)
+    // We can achieve something similar to attribute((always_inline)) with MSVC by
+    // using the __forceinline keyword, however this is not perfect. MSVC is
+    // much less aggressive about inlining, and even with the __forceinline keyword.
+    #define PHMAP_BASE_INTERNAL_FORCEINLINE __forceinline
+#else
+    // Use default attribute inline.
+    #define PHMAP_BASE_INTERNAL_FORCEINLINE inline PHMAP_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+
+namespace phmap {
+namespace base_internal {
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64Slow(uint64_t n) {
+    int zeroes = 60;
+    if (n >> 32) zeroes -= 32, n >>= 32;
+    if (n >> 16) zeroes -= 16, n >>= 16;
+    if (n >> 8) zeroes -= 8, n >>= 8;
+    if (n >> 4) zeroes -= 4, n >>= 4;
+    return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64(uint64_t n) {
+#if defined(_MSC_VER) && defined(_M_X64)
+    // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (_BitScanReverse64(&result, n)) {
+        return (int)(63 - result);
+    }
+    return 64;
+#elif defined(_MSC_VER) && !defined(__clang__)
+    // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if ((n >> 32) && _BitScanReverse(&result, (unsigned long)(n >> 32))) {
+        return 31 - result;
+    }
+    if (_BitScanReverse(&result, (unsigned long)n)) {
+        return 63 - result;
+    }
+    return 64;
+#elif defined(__GNUC__) || defined(__clang__)
+    // Use __builtin_clzll, which uses the following instructions:
+    //  x86: bsr
+    //  ARM64: clz
+    //  PPC: cntlzd
+    static_assert(sizeof(unsigned long long) == sizeof(n),  // NOLINT(runtime/int)
+                  "__builtin_clzll does not take 64-bit arg");
+
+    // Handle 0 as a special case because __builtin_clzll(0) is undefined.
+    if (n == 0) {
+        return 64;
+    }
+    return __builtin_clzll(n);
+#else
+    return CountLeadingZeros64Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros32Slow(uint64_t n) {
+    uint32_t zeroes = 28;
+    if (n >> 16) zeroes -= 16, n >>= 16;
+    if (n >> 8) zeroes -= 8, n >>= 8;
+    if (n >> 4) zeroes -= 4, n >>= 4;
+    return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountLeadingZeros32(uint32_t n) {
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (_BitScanReverse(&result, n)) {
+        return (uint32_t)(31 - result);
+    }
+    return 32;
+#elif defined(__GNUC__) || defined(__clang__)
+    // Use __builtin_clz, which uses the following instructions:
+    //  x86: bsr
+    //  ARM64: clz
+    //  PPC: cntlzd
+    static_assert(sizeof(int) == sizeof(n),
+                  "__builtin_clz does not take 32-bit arg");
+
+    // Handle 0 as a special case because __builtin_clz(0) is undefined.
+    if (n == 0) {
+        return 32;
+    }
+    return __builtin_clz(n);
+#else
+    return CountLeadingZeros32Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero64Slow(uint64_t n) {
+    uint32_t c = 63;
+    n &= ~n + 1;
+    if (n & 0x00000000FFFFFFFF) c -= 32;
+    if (n & 0x0000FFFF0000FFFF) c -= 16;
+    if (n & 0x00FF00FF00FF00FF) c -= 8;
+    if (n & 0x0F0F0F0F0F0F0F0F) c -= 4;
+    if (n & 0x3333333333333333) c -= 2;
+    if (n & 0x5555555555555555) c -= 1;
+    return c;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero64(uint64_t n) {
+#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_X64)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    _BitScanForward64(&result, n);
+    return (uint32_t)result;
+#elif defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (static_cast<uint32_t>(n) == 0) {
+        _BitScanForward(&result, (unsigned long)(n >> 32));
+        return result + 32;
+    }
+    _BitScanForward(&result, (unsigned long)n);
+    return result;
+#elif defined(__GNUC__) || defined(__clang__)
+    static_assert(sizeof(unsigned long long) == sizeof(n),  // NOLINT(runtime/int)
+                  "__builtin_ctzll does not take 64-bit arg");
+    return __builtin_ctzll(n);
+#else
+    return CountTrailingZerosNonZero64Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero32Slow(uint32_t n) {
+    uint32_t c = 31;
+    n &= ~n + 1;
+    if (n & 0x0000FFFF) c -= 16;
+    if (n & 0x00FF00FF) c -= 8;
+    if (n & 0x0F0F0F0F) c -= 4;
+    if (n & 0x33333333) c -= 2;
+    if (n & 0x55555555) c -= 1;
+    return c;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero32(uint32_t n) {
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    _BitScanForward(&result, n);
+    return (uint32_t)result;
+#elif defined(__GNUC__) || defined(__clang__)
+    static_assert(sizeof(int) == sizeof(n),
+                  "__builtin_ctz does not take 32-bit arg");
+    return __builtin_ctz(n);
+#else
+    return CountTrailingZerosNonZero32Slow(n);
+#endif
+}
+
+#undef PHMAP_BASE_INTERNAL_FORCEINLINE
+
+}  // namespace base_internal
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+// File: endian.h
+// -----------------------------------------------------------------------------
+
+namespace phmap {
+
+// Use compiler byte-swapping intrinsics if they are available.  32-bit
+// and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
+// The 16-bit version is available in Clang and GCC only as of GCC 4.8.0.
+// For simplicity, we enable them all only for GCC 4.8.0 or later.
+#if defined(__clang__) || \
+    (defined(__GNUC__) && \
+     ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+        return __builtin_bswap64(host_int);
+    }
+    inline uint32_t gbswap_32(uint32_t host_int) {
+        return __builtin_bswap32(host_int);
+    }
+    inline uint16_t gbswap_16(uint16_t host_int) {
+        return __builtin_bswap16(host_int);
+    }
+
+#elif defined(_MSC_VER)
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+        return _byteswap_uint64(host_int);
+    }
+    inline uint32_t gbswap_32(uint32_t host_int) {
+        return _byteswap_ulong(host_int);
+    }
+    inline uint16_t gbswap_16(uint16_t host_int) {
+        return _byteswap_ushort(host_int);
+    }
+
+#elif defined(__APPLE__)
+
+    inline uint64_t gbswap_64(uint64_t host_int) { return OSSwapInt16(host_int); }
+    inline uint32_t gbswap_32(uint32_t host_int) { return OSSwapInt32(host_int); }
+    inline uint16_t gbswap_16(uint16_t host_int) { return OSSwapInt64(host_int); }
+
+#else
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+#if defined(__GNUC__) && defined(__x86_64__) && !defined(__APPLE__)
+        // Adapted from /usr/include/byteswap.h.  Not available on Mac.
+        if (__builtin_constant_p(host_int)) {
+            return __bswap_constant_64(host_int);
+        } else {
+            uint64_t result;
+            __asm__("bswap %0" : "=r"(result) : "0"(host_int));
+            return result;
+        }
+#elif defined(__GLIBC__)
+        return bswap_64(host_int);
+#else
+        return (((host_int & uint64_t{0xFF}) << 56) |
+                ((host_int & uint64_t{0xFF00}) << 40) |
+                ((host_int & uint64_t{0xFF0000}) << 24) |
+                ((host_int & uint64_t{0xFF000000}) << 8) |
+                ((host_int & uint64_t{0xFF00000000}) >> 8) |
+                ((host_int & uint64_t{0xFF0000000000}) >> 24) |
+                ((host_int & uint64_t{0xFF000000000000}) >> 40) |
+                ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+#endif  // bswap_64
+    }
+
+    inline uint32_t gbswap_32(uint32_t host_int) {
+#if defined(__GLIBC__)
+        return bswap_32(host_int);
+#else
+        return (((host_int & uint32_t{0xFF}) << 24) |
+                ((host_int & uint32_t{0xFF00}) << 8) |
+                ((host_int & uint32_t{0xFF0000}) >> 8) |
+                ((host_int & uint32_t{0xFF000000}) >> 24));
+#endif
+    }
+
+    inline uint16_t gbswap_16(uint16_t host_int) {
+#if defined(__GLIBC__)
+        return bswap_16(host_int);
+#else
+        return (((host_int & uint16_t{0xFF}) << 8) |
+                ((host_int & uint16_t{0xFF00}) >> 8));
+#endif
+    }
+
+#endif  // intrinics available
+
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    // Definitions for ntohl etc. that don't require us to include
+    // netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
+    // than just #defining them because in debug mode, gcc doesn't
+    // correctly handle the (rather involved) definitions of bswap_32.
+    // gcc guarantees that inline functions are as fast as macros, so
+    // this isn't a performance hit.
+    inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
+    inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
+    inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    // These definitions are simpler on big-endian machines
+    // These are functions instead of macros to avoid self-assignment warnings
+    // on calls such as "i = ghtnol(i);".  This also provides type checking.
+    inline uint16_t ghtons(uint16_t x) { return x; }
+    inline uint32_t ghtonl(uint32_t x) { return x; }
+    inline uint64_t ghtonll(uint64_t x) { return x; }
+
+#else
+    #error \
+        "Unsupported byte order: Either PHMAP_IS_BIG_ENDIAN or " \
+           "PHMAP_IS_LITTLE_ENDIAN must be defined"
+#endif  // byte order
+
+inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
+inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
+inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and little-endian byte order
+//
+// Load/Store methods are alignment safe
+namespace little_endian {
+// Conversion functions.
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return x; }
+    inline uint16_t ToHost16(uint16_t x) { return x; }
+
+    inline uint32_t FromHost32(uint32_t x) { return x; }
+    inline uint32_t ToHost32(uint32_t x) { return x; }
+
+    inline uint64_t FromHost64(uint64_t x) { return x; }
+    inline uint64_t ToHost64(uint64_t x) { return x; }
+
+    inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+    inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+    inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+    inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+    inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+    inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+    inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in little-endian order.
+// ------------------------------------------------------------------
+inline uint16_t Load16(const void *p) {
+  return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace little_endian
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and big-endian byte order (same as network byte order)
+//
+// Load/Store methods are alignment safe
+namespace big_endian {
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+    inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+    inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+    inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+    inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+    inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+    inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return x; }
+    inline uint16_t ToHost16(uint16_t x) { return x; }
+
+    inline uint32_t FromHost32(uint32_t x) { return x; }
+    inline uint32_t ToHost32(uint32_t x) { return x; }
+
+    inline uint64_t FromHost64(uint64_t x) { return x; }
+    inline uint64_t ToHost64(uint64_t x) { return x; }
+
+    inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in big-endian order.
+inline uint16_t Load16(const void *p) {
+  return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace big_endian
+
+}  // namespace phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_bits_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_config.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_config.h
new file mode 100644
index 00000000..18434f6b
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_config.h
@@ -0,0 +1,789 @@
+#if !defined(phmap_config_h_guard_)
+#define phmap_config_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#define PHMAP_VERSION_MAJOR 1
+#define PHMAP_VERSION_MINOR 3
+#define PHMAP_VERSION_PATCH 8
+
+// Included for the __GLIBC__ macro (or similar macros on other systems).
+#include <limits.h>
+
+#ifdef __cplusplus
+    // Included for __GLIBCXX__, _LIBCPP_VERSION
+    #include <cstddef>
+#endif  // __cplusplus
+
+#if defined(__APPLE__)
+    // Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
+    // __IPHONE_8_0.
+    #include <Availability.h>
+    #include <TargetConditionals.h>
+#endif
+
+#define PHMAP_XSTR(x) PHMAP_STR(x)
+#define PHMAP_STR(x) #x
+#define PHMAP_VAR_NAME_VALUE(var) #var "="  PHMAP_STR(var)
+
+// -----------------------------------------------------------------------------
+// Some sanity checks
+// -----------------------------------------------------------------------------
+//#if defined(__CYGWIN__)
+//    #error "Cygwin is not supported."
+//#endif
+
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023918 && !defined(__clang__)
+    #error "phmap requires Visual Studio 2015 Update 2 or higher."
+#endif
+
+// We support gcc 4.7 and later.
+#if defined(__GNUC__) && !defined(__clang__)
+    #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
+        #error "phmap requires gcc 4.7 or higher."
+    #endif
+#endif
+
+// We support Apple Xcode clang 4.2.1 (version 421.11.65) and later.
+// This corresponds to Apple Xcode version 4.5.
+#if defined(__apple_build_version__) && __apple_build_version__ < 4211165
+    #error "phmap requires __apple_build_version__ of 4211165 or higher."
+#endif
+
+// Enforce C++11 as the minimum. 
+#if defined(__cplusplus) && !defined(_MSC_VER)
+    #if __cplusplus < 201103L
+        #error "C++ versions less than C++11 are not supported."
+    #endif
+#endif
+
+// We have chosen glibc 2.12 as the minimum 
+#if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
+    #if !__GLIBC_PREREQ(2, 12)
+        #error "Minimum required version of glibc is 2.12."
+    #endif
+#endif
+
+#if defined(_STLPORT_VERSION)
+    #error "STLPort is not supported."
+#endif
+
+#if CHAR_BIT != 8
+    #error "phmap assumes CHAR_BIT == 8."
+#endif
+
+// phmap currently assumes that an int is 4 bytes. 
+#if INT_MAX < 2147483647
+    #error "phmap assumes that int is at least 4 bytes. "
+#endif
+
+
+
+// -----------------------------------------------------------------------------
+// Compiler Feature Checks
+// -----------------------------------------------------------------------------
+
+#ifdef __has_builtin
+    #define PHMAP_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+    #define PHMAP_HAVE_BUILTIN(x) 0
+#endif
+
+#if (defined(_MSVC_LANG) && _MSVC_LANG >= 201703) || __cplusplus >= 201703
+    #define PHMAP_HAVE_CC17 1
+#else
+    #define PHMAP_HAVE_CC17 0
+#endif
+
+#define PHMAP_BRANCHLESS 1
+
+#ifdef __has_feature
+#define PHMAP_HAVE_FEATURE(f) __has_feature(f)
+#else
+#define PHMAP_HAVE_FEATURE(f) 0
+#endif
+
+// Portable check for GCC minimum version:
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+    #define PHMAP_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+#else
+    #define PHMAP_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
+#endif
+
+#if defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__)
+    #define PHMAP_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
+#else
+    #define PHMAP_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
+#endif
+
+// ----------------------------------------------------------------
+// Checks whether `std::is_trivially_destructible<T>` is supported.
+// ----------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
+#elif defined(_LIBCPP_VERSION) || defined(_MSC_VER) ||                     \
+    (!defined(__clang__) && defined(__GNUC__) && defined(__GLIBCXX__) &&  PHMAP_INTERNAL_HAVE_MIN_GNUC_VERSION(4, 8))
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
+#endif
+
+// --------------------------------------------------------------
+// Checks whether `std::is_trivially_default_constructible<T>` is 
+// supported.
+// --------------------------------------------------------------
+#if defined(PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
+#elif defined(PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
+#elif (defined(__clang__) && defined(_LIBCPP_VERSION)) ||        \
+    (!defined(__clang__) && defined(__GNUC__) &&                 \
+     PHMAP_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 1) && \
+     (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__))) ||      \
+    (defined(_MSC_VER) && !defined(__NVCC__))
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
+#endif
+
+// -------------------------------------------------------------------
+// Checks whether C++11's `thread_local` storage duration specifier is
+// supported.
+// -------------------------------------------------------------------
+#ifdef PHMAP_HAVE_THREAD_LOCAL
+    #error PHMAP_HAVE_THREAD_LOCAL cannot be directly set
+#elif defined(__APPLE__)
+    #if __has_feature(cxx_thread_local) && \
+        !(TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0)
+        #define PHMAP_HAVE_THREAD_LOCAL 1
+    #endif
+#else  // !defined(__APPLE__)
+    #define PHMAP_HAVE_THREAD_LOCAL 1
+#endif
+
+#if defined(__ANDROID__) && defined(__clang__)
+
+    #if __has_include(<android/ndk-version.h>)
+        #include <android/ndk-version.h>
+    #endif  // __has_include(<android/ndk-version.h>)
+
+    #if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
+        defined(__NDK_MINOR__) &&                                               \
+        ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+        #undef PHMAP_HAVE_TLS
+        #undef PHMAP_HAVE_THREAD_LOCAL
+    #endif
+#endif 
+
+// ------------------------------------------------------------
+// Checks whether the __int128 compiler extension for a 128-bit 
+// integral type is supported.
+// ------------------------------------------------------------
+#ifdef PHMAP_HAVE_INTRINSIC_INT128
+    #error PHMAP_HAVE_INTRINSIC_INT128 cannot be directly set
+#elif defined(__SIZEOF_INT128__)
+    #if (defined(__clang__) && !defined(_WIN32) && !defined(__aarch64__)) || \
+        (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                \
+        (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
+        #define PHMAP_HAVE_INTRINSIC_INT128 1
+    #elif defined(__CUDACC__)
+        #if __CUDACC_VER__ >= 70000
+            #define PHMAP_HAVE_INTRINSIC_INT128 1
+        #endif  // __CUDACC_VER__ >= 70000
+    #endif  // defined(__CUDACC__)
+#endif
+
+// ------------------------------------------------------------------
+// Checks whether the compiler both supports and enables exceptions. 
+// ------------------------------------------------------------------
+#ifdef PHMAP_HAVE_EXCEPTIONS
+    #error PHMAP_HAVE_EXCEPTIONS cannot be directly set.
+#elif defined(__clang__)
+    #if defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+        #define PHMAP_HAVE_EXCEPTIONS 1
+    #endif  // defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+#elif !(defined(__GNUC__) && (__GNUC__ < 5) && !defined(__EXCEPTIONS)) &&    \
+    !(defined(__GNUC__) && (__GNUC__ >= 5) && !defined(__cpp_exceptions)) && \
+    !(defined(_MSC_VER) && !defined(_CPPUNWIND))
+    #define PHMAP_HAVE_EXCEPTIONS 1
+#endif
+
+
+// -----------------------------------------------------------------------
+// Checks whether the platform has an mmap(2) implementation as defined in
+// POSIX.1-2001.
+// -----------------------------------------------------------------------
+#ifdef PHMAP_HAVE_MMAP
+    #error PHMAP_HAVE_MMAP cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||   \
+    defined(__ros__) || defined(__native_client__) || defined(__asmjs__) || \
+    defined(__wasm__) || defined(__Fuchsia__) || defined(__sun) || \
+    defined(__ASYLO__)
+    #define PHMAP_HAVE_MMAP 1
+#endif
+
+// -----------------------------------------------------------------------
+// Checks the endianness of the platform.
+// -----------------------------------------------------------------------
+#if defined(PHMAP_IS_BIG_ENDIAN)
+    #error "PHMAP_IS_BIG_ENDIAN cannot be directly set."
+#endif
+
+#if defined(PHMAP_IS_LITTLE_ENDIAN)
+    #error "PHMAP_IS_LITTLE_ENDIAN cannot be directly set."
+#endif
+
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    #define PHMAP_IS_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    #define PHMAP_IS_BIG_ENDIAN 1
+#elif defined(_WIN32)
+    #define PHMAP_IS_LITTLE_ENDIAN 1
+#else
+    #error "phmap endian detection needs to be set up for your compiler"
+#endif
+
+#if defined(__APPLE__) && defined(_LIBCPP_VERSION) && \
+    defined(__MAC_OS_X_VERSION_MIN_REQUIRED__) &&     \
+    __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101400
+    #define PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 1
+#else
+    #define PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 0
+#endif
+
+// ---------------------------------------------------------------------------
+// Checks whether C++17 std::any is available by checking whether <any> exists.
+// ---------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_ANY
+    #error "PHMAP_HAVE_STD_ANY cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<any>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_ANY 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+    #error "PHMAP_HAVE_STD_OPTIONAL cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<optional>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_OPTIONAL 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_VARIANT
+    #error "PHMAP_HAVE_STD_VARIANT cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<variant>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_VARIANT 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_STRING_VIEW
+    #error "PHMAP_HAVE_STD_STRING_VIEW cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<string_view>) && __cplusplus >= 201703L && \
+        (!defined(_MSC_VER) || _MSC_VER >= 1920) // vs2019
+        #define PHMAP_HAVE_STD_STRING_VIEW 1
+    #endif
+#endif
+
+// #pragma message(PHMAP_VAR_NAME_VALUE(_MSVC_LANG))
+
+#if defined(_MSC_VER) && _MSC_VER >= 1910 && PHMAP_HAVE_CC17
+    // #define PHMAP_HAVE_STD_ANY 1
+    #define PHMAP_HAVE_STD_OPTIONAL 1
+    #define PHMAP_HAVE_STD_VARIANT 1
+    #if !defined(PHMAP_HAVE_STD_STRING_VIEW) && _MSC_VER >= 1920
+        #define PHMAP_HAVE_STD_STRING_VIEW 1
+    #endif
+#endif
+
+#if PHMAP_HAVE_CC17
+    #define PHMAP_HAVE_SHARED_MUTEX 1
+#endif
+
+#ifndef PHMAP_HAVE_STD_STRING_VIEW
+    #define PHMAP_HAVE_STD_STRING_VIEW 0
+#endif
+
+// In debug mode, MSVC 2017's std::variant throws a EXCEPTION_ACCESS_VIOLATION
+// SEH exception from emplace for variant<SomeStruct> when constructing the
+// struct can throw. This defeats some of variant_test and
+// variant_exception_safety_test.
+#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
+    #define PHMAP_INTERNAL_MSVC_2017_DBG_MODE
+#endif
+
+// ---------------------------------------------------------------------------
+// Checks whether wchar_t is treated as a native type
+// (MSVC: /Zc:wchar_t- treats wchar_t as unsigned short)
+// ---------------------------------------------------------------------------
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+#define PHMAP_HAS_NATIVE_WCHAR_T
+#endif
+
+// -----------------------------------------------------------------------------
+// Sanitizer Attributes
+// -----------------------------------------------------------------------------
+//
+// Sanitizer-related attributes are not "defined" in this file (and indeed
+// are not defined as such in any file). To utilize the following
+// sanitizer-related attributes within your builds, define the following macros
+// within your build using a `-D` flag, along with the given value for
+// `-fsanitize`:
+//
+//   * `ADDRESS_SANITIZER` + `-fsanitize=address` (Clang, GCC 4.8)
+//   * `MEMORY_SANITIZER` + `-fsanitize=memory` (Clang-only)
+//   * `THREAD_SANITIZER + `-fsanitize=thread` (Clang, GCC 4.8+)
+//   * `UNDEFINED_BEHAVIOR_SANITIZER` + `-fsanitize=undefined` (Clang, GCC 4.9+)
+//   * `CONTROL_FLOW_INTEGRITY` + -fsanitize=cfi (Clang-only)
+// -----------------------------------------------------------------------------
+
+// -----------------------------------------------------------------------------
+// A function-like feature checking macro that is a wrapper around
+// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+// nonzero constant integer if the attribute is supported or 0 if not.
+//
+// It evaluates to zero if `__has_attribute` is not defined by the compiler.
+// -----------------------------------------------------------------------------
+#ifdef __has_attribute
+    #define PHMAP_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+    #define PHMAP_HAVE_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// A function-like feature checking macro that accepts C++11 style attributes.
+// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
+// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
+// find `__has_cpp_attribute`, will evaluate to 0.
+// -----------------------------------------------------------------------------
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+    #define PHMAP_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+    #define PHMAP_HAVE_CPP_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Attributes
+// -----------------------------------------------------------------------------
+#if PHMAP_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+      __attribute__((__format__(__printf__, string_index, first_to_check)))
+    #define PHMAP_SCANF_ATTRIBUTE(string_index, first_to_check) \
+      __attribute__((__format__(__scanf__, string_index, first_to_check)))
+#else
+    #define PHMAP_PRINTF_ATTRIBUTE(string_index, first_to_check)
+    #define PHMAP_SCANF_ATTRIBUTE(string_index, first_to_check)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(always_inline) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+    #define PHMAP_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
+#else
+    #define PHMAP_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+#if !defined(__INTEL_COMPILER) && (PHMAP_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__)))
+    #define PHMAP_ATTRIBUTE_NOINLINE __attribute__((noinline))
+    #define PHMAP_HAVE_ATTRIBUTE_NOINLINE 1
+#else
+    #define PHMAP_ATTRIBUTE_NOINLINE
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(disable_tail_calls)
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL \
+      __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
+#endif
+
+#if (PHMAP_HAVE_ATTRIBUTE(weak) || \
+     (defined(__GNUC__) && !defined(__clang__))) && \
+    !(defined(__llvm__) && defined(_WIN32))
+    #undef PHMAP_ATTRIBUTE_WEAK
+    #define PHMAP_ATTRIBUTE_WEAK __attribute__((weak))
+    #define PHMAP_HAVE_ATTRIBUTE_WEAK 1
+#else
+    #define PHMAP_ATTRIBUTE_WEAK
+    #define PHMAP_HAVE_ATTRIBUTE_WEAK 0
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
+#else
+    #define PHMAP_ATTRIBUTE_NONNULL(...)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#elif defined(_MSC_VER)
+    #define PHMAP_ATTRIBUTE_NORETURN __declspec(noreturn)
+#else
+    #define PHMAP_ATTRIBUTE_NORETURN
+#endif
+
+#if defined(__GNUC__) && defined(ADDRESS_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_ADDRESS
+#endif
+
+#if defined(__GNUC__) && defined(MEMORY_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_MEMORY
+#endif
+
+#if defined(__GNUC__) && defined(THREAD_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_THREAD
+#endif
+
+#if defined(__GNUC__) && \
+    (defined(UNDEFINED_BEHAVIOR_SANITIZER) || defined(ADDRESS_SANITIZER))
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+      __attribute__((no_sanitize("undefined")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+#endif
+
+#if defined(__GNUC__) && defined(CONTROL_FLOW_INTEGRITY)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_CFI
+#endif
+
+#if defined(__GNUC__) && defined(SAFESTACK_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
+      __attribute__((no_sanitize("safe-stack")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(returns_nonnull) || \
+    (defined(__GNUC__) && \
+     (__GNUC__ > 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) && \
+     !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+    #define PHMAP_ATTRIBUTE_RETURNS_NONNULL
+#endif
+
+#ifdef PHMAP_HAVE_ATTRIBUTE_SECTION
+    #error PHMAP_HAVE_ATTRIBUTE_SECTION cannot be directly set
+#elif (PHMAP_HAVE_ATTRIBUTE(section) ||                \
+       (defined(__GNUC__) && !defined(__clang__))) && \
+    !defined(__APPLE__) && PHMAP_HAVE_ATTRIBUTE_WEAK
+    #define PHMAP_HAVE_ATTRIBUTE_SECTION 1
+    #ifndef PHMAP_ATTRIBUTE_SECTION
+        #define PHMAP_ATTRIBUTE_SECTION(name) \
+          __attribute__((section(#name))) __attribute__((noinline))
+    #endif
+    #ifndef PHMAP_ATTRIBUTE_SECTION_VARIABLE
+        #define PHMAP_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
+    #endif
+    #ifndef PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS
+        #define PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
+          extern char __start_##name[] PHMAP_ATTRIBUTE_WEAK;    \
+          extern char __stop_##name[] PHMAP_ATTRIBUTE_WEAK
+    #endif
+    #ifndef PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS
+        #define PHMAP_INIT_ATTRIBUTE_SECTION_VARS(name)
+        #define PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+    #endif
+    #define PHMAP_ATTRIBUTE_SECTION_START(name) \
+      (reinterpret_cast<void *>(__start_##name))
+    #define PHMAP_ATTRIBUTE_SECTION_STOP(name) \
+      (reinterpret_cast<void *>(__stop_##name))
+#else  // !PHMAP_HAVE_ATTRIBUTE_SECTION
+    #define PHMAP_HAVE_ATTRIBUTE_SECTION 0
+    #define PHMAP_ATTRIBUTE_SECTION(name)
+    #define PHMAP_ATTRIBUTE_SECTION_VARIABLE(name)
+    #define PHMAP_INIT_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
+    #define PHMAP_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+#endif  // PHMAP_ATTRIBUTE_SECTION
+
+#if PHMAP_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #if defined(__i386__)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
+          __attribute__((force_align_arg_pointer))
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+    #elif defined(__x86_64__)
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #else  // !__i386__ && !__x86_64
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #endif  // __i386__
+#else
+    #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(nodiscard)
+    #define PHMAP_MUST_USE_RESULT [[nodiscard]]
+#elif defined(__clang__) && PHMAP_HAVE_ATTRIBUTE(warn_unused_result)
+    #define PHMAP_MUST_USE_RESULT __attribute__((warn_unused_result))
+#else
+    #define PHMAP_MUST_USE_RESULT
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_HOT __attribute__((hot))
+#else
+    #define PHMAP_ATTRIBUTE_HOT
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_COLD __attribute__((cold))
+#else
+    #define PHMAP_ATTRIBUTE_COLD
+#endif
+
+#if defined(__clang__)
+    #if PHMAP_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
+        #define PHMAP_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+    #else
+        #define PHMAP_ATTRIBUTE_REINITIALIZES
+    #endif
+#else
+    #define PHMAP_ATTRIBUTE_REINITIALIZES
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
+    #undef PHMAP_ATTRIBUTE_UNUSED
+    #define PHMAP_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#else
+    #define PHMAP_ATTRIBUTE_UNUSED
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
+#else
+    #define PHMAP_ATTRIBUTE_INITIAL_EXEC
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_PACKED __attribute__((__packed__))
+#else
+    #define PHMAP_ATTRIBUTE_PACKED
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#else
+    #define PHMAP_ATTRIBUTE_FUNC_ALIGN(bytes)
+#endif
+
+// ----------------------------------------------------------------------
+// Figure out SSE support
+// ----------------------------------------------------------------------
+#ifndef PHMAP_HAVE_SSE2
+    #if defined(__SSE2__) ||  \
+        (defined(_MSC_VER) && \
+         (defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)))
+        #define PHMAP_HAVE_SSE2 1
+    #else
+        #define PHMAP_HAVE_SSE2 0
+    #endif
+#endif
+
+#ifndef PHMAP_HAVE_SSSE3
+    #if defined(__SSSE3__) || defined(__AVX2__)
+        #define PHMAP_HAVE_SSSE3 1
+    #else
+        #define PHMAP_HAVE_SSSE3 0
+    #endif
+#endif
+
+#if PHMAP_HAVE_SSSE3 && !PHMAP_HAVE_SSE2
+    #error "Bad configuration!"
+#endif
+
+#if PHMAP_HAVE_SSE2
+    #include <emmintrin.h>
+#endif
+
+#if PHMAP_HAVE_SSSE3
+    #include <tmmintrin.h>
+#endif
+
+
+// ----------------------------------------------------------------------
+// constexpr if
+// ----------------------------------------------------------------------
+#if PHMAP_HAVE_CC17
+    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
+#else 
+    #define PHMAP_IF_CONSTEXPR(expr) if ((expr))
+#endif
+
+// ----------------------------------------------------------------------
+// base/macros.h
+// ----------------------------------------------------------------------
+
+// PHMAP_ARRAYSIZE()
+//
+// Returns the number of elements in an array as a compile-time constant, which
+// can be used in defining new arrays. If you use this macro on a pointer by
+// mistake, you will get a compile-time error.
+#define PHMAP_ARRAYSIZE(array) \
+  (sizeof(::phmap::macros_internal::ArraySizeHelper(array)))
+
+namespace phmap {
+namespace macros_internal {
+    // Note: this internal template function declaration is used by PHMAP_ARRAYSIZE.
+    // The function doesn't need a definition, as we only use its type.
+    template <typename T, size_t N>
+    auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
+}  // namespace macros_internal
+}  // namespace phmap
+
+// TODO(zhangxy): Use c++17 standard [[fallthrough]] macro, when supported.
+#if defined(__clang__) && defined(__has_warning)
+    #if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+        #define PHMAP_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+    #endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+    #define PHMAP_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+#ifndef PHMAP_FALLTHROUGH_INTENDED
+    #define PHMAP_FALLTHROUGH_INTENDED \
+      do {  } while (0)
+#endif
+
+// PHMAP_DEPRECATED()
+//
+// Marks a deprecated class, struct, enum, function, method and variable
+// declarations. The macro argument is used as a custom diagnostic message (e.g.
+// suggestion of a better alternative).
+//
+// Example:
+//
+//   class PHMAP_DEPRECATED("Use Bar instead") Foo {...};
+//   PHMAP_DEPRECATED("Use Baz instead") void Bar() {...}
+//
+// Every usage of a deprecated entity will trigger a warning when compiled with
+// clang's `-Wdeprecated-declarations` option. This option is turned off by
+// default, but the warnings will be reported by clang-tidy.
+#if defined(__clang__) && __cplusplus >= 201103L
+    #define PHMAP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+
+#ifndef PHMAP_DEPRECATED
+    #define PHMAP_DEPRECATED(message)
+#endif
+
+// PHMAP_BAD_CALL_IF()
+//
+// Used on a function overload to trap bad calls: any call that matches the
+// overload will cause a compile-time error. This macro uses a clang-specific
+// "enable_if" attribute, as described at
+// http://clang.llvm.org/docs/AttributeReference.html#enable-if
+//
+// Overloads which use this macro should be bracketed by
+// `#ifdef PHMAP_BAD_CALL_IF`.
+//
+// Example:
+//
+//   int isdigit(int c);
+//   #ifdef PHMAP_BAD_CALL_IF
+//   int isdigit(int c)
+//     PHMAP_BAD_CALL_IF(c <= -1 || c > 255,
+//                       "'c' must have the value of an unsigned char or EOF");
+//   #endif // PHMAP_BAD_CALL_IF
+
+#if defined(__clang__)
+    #if __has_attribute(enable_if)
+        #define PHMAP_BAD_CALL_IF(expr, msg) \
+            __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
+    #endif
+#endif
+
+// PHMAP_ASSERT()
+//
+// In C++11, `assert` can't be used portably within constexpr functions.
+// PHMAP_ASSERT functions as a runtime assert but works in C++11 constexpr
+// functions.  Example:
+//
+// constexpr double Divide(double a, double b) {
+//   return PHMAP_ASSERT(b != 0), a / b;
+// }
+//
+// This macro is inspired by
+// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+#if defined(NDEBUG)
+    #define PHMAP_ASSERT(expr) (false ? (void)(expr) : (void)0)
+#else
+    #define PHMAP_ASSERT(expr)              \
+      (PHMAP_PREDICT_TRUE((expr)) ? (void)0 \
+                                 : [] { assert(false && #expr); }())  // NOLINT
+#endif
+
+#ifdef PHMAP_HAVE_EXCEPTIONS
+    #define PHMAP_INTERNAL_TRY try
+    #define PHMAP_INTERNAL_CATCH_ANY catch (...)
+    #define PHMAP_INTERNAL_RETHROW do { throw; } while (false)
+#else  // PHMAP_HAVE_EXCEPTIONS
+    #define PHMAP_INTERNAL_TRY if (true)
+    #define PHMAP_INTERNAL_CATCH_ANY else if (false)
+    #define PHMAP_INTERNAL_RETHROW do {} while (false)
+#endif  // PHMAP_HAVE_EXCEPTIONS
+
+
+#endif // phmap_config_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_dump.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_dump.h
new file mode 100644
index 00000000..93eda8c6
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_dump.h
@@ -0,0 +1,288 @@
+#if !defined(phmap_dump_h_guard_)
+#define phmap_dump_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+//       providing dump/load/mmap_load
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include "phmap.h"
+namespace phmap
+{
+
+namespace type_traits_internal {
+
+#if defined(__GLIBCXX__) && __GLIBCXX__ < 20150801
+    template<typename T> struct IsTriviallyCopyable : public std::integral_constant<bool, __has_trivial_copy(T)> {};
+#else
+    template<typename T> struct IsTriviallyCopyable : public std::is_trivially_copyable<T> {};
+#endif
+
+template <class T1, class T2>
+struct IsTriviallyCopyable<std::pair<T1, T2>> {
+    static constexpr bool value = IsTriviallyCopyable<T1>::value && IsTriviallyCopyable<T2>::value;
+};
+}
+
+namespace priv {
+
+#if !defined(PHMAP_NON_DETERMINISTIC) && !defined(PHMAP_DISABLE_DUMP)
+
+// ------------------------------------------------------------------------
+// dump/load for raw_hash_set
+// ------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+template<typename OutputArchive>
+bool raw_hash_set<Policy, Hash, Eq, Alloc>::phmap_dump(OutputArchive& ar) const {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+
+    ar.saveBinary(&size_, sizeof(size_t));
+    ar.saveBinary(&capacity_, sizeof(size_t));
+    if (size_ == 0)
+        return true;
+    ar.saveBinary(ctrl_,  sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1));
+    ar.saveBinary(slots_, sizeof(slot_type) * capacity_);
+    return true;
+}
+
+template <class Policy, class Hash, class Eq, class Alloc>
+template<typename InputArchive>
+bool raw_hash_set<Policy, Hash, Eq, Alloc>::phmap_load(InputArchive& ar) {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+    raw_hash_set<Policy, Hash, Eq, Alloc>().swap(*this); // clear any existing content
+    ar.loadBinary(&size_, sizeof(size_t));
+    ar.loadBinary(&capacity_, sizeof(size_t));
+
+    if (capacity_) {
+        // allocate memory for ctrl_ and slots_
+        initialize_slots(capacity_);
+    }
+    if (size_ == 0)
+        return true;
+    ar.loadBinary(ctrl_,  sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1));
+    ar.loadBinary(slots_, sizeof(slot_type) * capacity_);
+    return true;
+}
+
+// ------------------------------------------------------------------------
+// dump/load for parallel_hash_set
+// ------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+template<typename OutputArchive>
+bool parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc>::phmap_dump(OutputArchive& ar) const {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                  "value_type should be trivially copyable");
+
+    size_t submap_count = subcnt();
+    ar.saveBinary(&submap_count, sizeof(size_t));
+    for (size_t i = 0; i < sets_.size(); ++i) {
+        auto& inner = sets_[i];
+        typename Lockable::UniqueLock m(const_cast<Inner&>(inner));
+        if (!inner.set_.phmap_dump(ar)) {
+            std::cerr << "Failed to dump submap " << i << std::endl;
+            return false;
+        }
+    }
+    return true;
+}
+
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+template<typename InputArchive>
+bool parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc>::phmap_load(InputArchive& ar) {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                  "value_type should be trivially copyable");
+
+    size_t submap_count = 0;
+    ar.loadBinary(&submap_count, sizeof(size_t));
+    if (submap_count != subcnt()) {
+        std::cerr << "submap count(" << submap_count << ") != N(" << N << ")" << std::endl;
+        return false;
+    }
+
+    for (size_t i = 0; i < submap_count; ++i) {            
+        auto& inner = sets_[i];
+        typename Lockable::UniqueLock m(const_cast<Inner&>(inner));
+        if (!inner.set_.phmap_load(ar)) {
+            std::cerr << "Failed to load submap " << i << std::endl;
+            return false;
+        }
+    }
+    return true;
+}
+
+#endif // !defined(PHMAP_NON_DETERMINISTIC) && !defined(PHMAP_DISABLE_DUMP)
+
+} // namespace priv
+
+
+
+// ------------------------------------------------------------------------
+// BinaryArchive
+//       File is closed when archive object is destroyed
+// ------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+class BinaryOutputArchive {
+public:
+    BinaryOutputArchive(const char *file_path) {
+        ofs_.open(file_path, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
+    }
+
+    bool saveBinary(const void *p, size_t sz) {
+        ofs_.write(reinterpret_cast<const char*>(p), sz);
+        return true;
+    }
+
+    template<typename V>
+    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
+    saveBinary(const V& v) {
+        ofs_.write(reinterpret_cast<const char *>(&v), sizeof(V));
+        return true;
+    }
+
+    template<typename Map>
+    auto saveBinary(const Map& v) -> decltype(v.phmap_dump(*this), bool())
+    {
+        return v.phmap_dump(*this);
+    }
+
+private:
+    std::ofstream ofs_;
+};
+
+
+class BinaryInputArchive {
+public:
+    BinaryInputArchive(const char * file_path) {
+        ifs_.open(file_path, std::ofstream::in | std::ofstream::binary);
+    }
+
+    bool loadBinary(void* p, size_t sz) {
+        ifs_.read(reinterpret_cast<char*>(p), sz);
+        return true;
+    }
+
+    template<typename V>
+    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
+    loadBinary(V* v) {
+        ifs_.read(reinterpret_cast<char *>(v), sizeof(V));
+        return true;
+    }
+
+    template<typename Map>
+    auto loadBinary(Map* v) -> decltype(v->phmap_load(*this), bool())
+    {
+        return v->phmap_load(*this);
+    }
+    
+private:
+    std::ifstream ifs_;
+};
+
+} // namespace phmap
+
+
+#ifdef CEREAL_SIZE_TYPE
+
+template <class T>
+using PhmapTrivCopyable = typename phmap::type_traits_internal::IsTriviallyCopyable<T>;
+    
+namespace cereal
+{
+    // Overload Cereal serialization code for phmap::flat_hash_map
+    // -----------------------------------------------------------
+    template <class K, class V, class Hash, class Eq, class A>
+    void save(typename std::enable_if<PhmapTrivCopyable<K>::value && PhmapTrivCopyable<V>::value, typename cereal::BinaryOutputArchive>::type &ar,
+              phmap::flat_hash_map<K, V, Hash, Eq, A> const &hmap)
+    {
+        hmap.phmap_dump(ar);
+    }
+
+    template <class K, class V, class Hash, class Eq, class A>
+    void load(typename std::enable_if<PhmapTrivCopyable<K>::value && PhmapTrivCopyable<V>::value, typename cereal::BinaryInputArchive>::type &ar, 
+              phmap::flat_hash_map<K, V, Hash, Eq, A>  &hmap)
+    {
+        hmap.phmap_load(ar);
+    }
+
+
+    // Overload Cereal serialization code for phmap::parallel_flat_hash_map
+    // --------------------------------------------------------------------
+    template <class K, class V, class Hash, class Eq, class A, size_t N, class Mtx_>
+    void save(typename std::enable_if<PhmapTrivCopyable<K>::value && PhmapTrivCopyable<V>::value, typename cereal::BinaryOutputArchive>::type &ar,
+              phmap::parallel_flat_hash_map<K, V, Hash, Eq, A, N, Mtx_> const &hmap)
+    {
+        hmap.phmap_dump(ar);
+    }
+
+    template <class K, class V, class Hash, class Eq, class A, size_t N, class Mtx_>
+    void load(typename std::enable_if<PhmapTrivCopyable<K>::value && PhmapTrivCopyable<V>::value, typename cereal::BinaryInputArchive>::type &ar, 
+              phmap::parallel_flat_hash_map<K, V, Hash, Eq, A, N, Mtx_>  &hmap)
+    {
+        hmap.phmap_load(ar);
+    }
+
+    // Overload Cereal serialization code for phmap::flat_hash_set
+    // -----------------------------------------------------------
+    template <class K, class Hash, class Eq, class A>
+    void save(typename std::enable_if<PhmapTrivCopyable<K>::value, typename cereal::BinaryOutputArchive>::type &ar,
+              phmap::flat_hash_set<K, Hash, Eq, A> const &hset)
+    {
+        hset.phmap_dump(ar);
+    }
+
+    template <class K, class Hash, class Eq, class A>
+    void load(typename std::enable_if<PhmapTrivCopyable<K>::value, typename cereal::BinaryInputArchive>::type &ar, 
+              phmap::flat_hash_set<K, Hash, Eq, A>  &hset)
+    {
+        hset.phmap_load(ar);
+    }
+
+    // Overload Cereal serialization code for phmap::parallel_flat_hash_set
+    // --------------------------------------------------------------------
+    template <class K, class Hash, class Eq, class A, size_t N, class Mtx_>
+    void save(typename std::enable_if<PhmapTrivCopyable<K>::value, typename cereal::BinaryOutputArchive>::type &ar,
+              phmap::parallel_flat_hash_set<K, Hash, Eq, A, N, Mtx_> const &hset)
+    {
+        hset.phmap_dump(ar);
+    }
+
+    template <class K, class Hash, class Eq, class A, size_t N, class Mtx_>
+    void load(typename std::enable_if<PhmapTrivCopyable<K>::value, typename cereal::BinaryInputArchive>::type &ar, 
+              phmap::parallel_flat_hash_set<K, Hash, Eq, A, N, Mtx_>  &hset)
+    {
+        hset.phmap_load(ar);
+    }
+}
+
+#endif
+
+
+
+
+#endif // phmap_dump_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_fwd_decl.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_fwd_decl.h
new file mode 100644
index 00000000..a7719c49
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_fwd_decl.h
@@ -0,0 +1,154 @@
+#if !defined(phmap_fwd_decl_h_guard_)
+#define phmap_fwd_decl_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+#endif
+
+#include <memory>
+#include <utility>
+
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(ABSL_HASH_HASH_H_)
+    namespace absl { template <class T> struct Hash; };
+#endif
+
+namespace phmap {
+
+#if defined(PHMAP_USE_ABSL_HASH)
+    template <class T> using Hash = ::absl::Hash<T>;
+#else
+    template <class T> struct Hash;
+#endif
+
+    template <class T> struct EqualTo;
+    template <class T> struct Less;
+    template <class T> using Allocator      = typename std::allocator<T>;
+    template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
+
+    class NullMutex;
+
+    namespace priv {
+
+        // The hash of an object of type T is computed by using phmap::Hash.
+        template <class T, class E = void>
+        struct HashEq 
+        {
+            using Hash = phmap::Hash<T>;
+            using Eq   = phmap::EqualTo<T>;
+        };
+
+        template <class T>
+        using hash_default_hash = typename priv::HashEq<T>::Hash;
+
+        template <class T>
+        using hash_default_eq = typename priv::HashEq<T>::Eq;
+
+        // type alias for std::allocator so we can forward declare without including other headers
+        template <class T>  
+        using Allocator = typename phmap::Allocator<T>;
+
+        // type alias for std::pair so we can forward declare without including other headers
+        template<class T1, class T2> 
+        using Pair = typename phmap::Pair<T1, T2>;
+
+    }  // namespace priv
+
+    // ------------- forward declarations for hash containers ----------------------------------
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>>  // alias for std::allocator
+        class flat_hash_set;
+
+    template <class K, class V,
+              class Hash  = phmap::priv::hash_default_hash<K>,
+              class Eq    = phmap::priv::hash_default_eq<K>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const K, V>>> // alias for std::allocator
+        class flat_hash_map;
+    
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>> // alias for std::allocator
+        class node_hash_set;
+
+    template <class Key, class Value,
+              class Hash  = phmap::priv::hash_default_hash<Key>,
+              class Eq    = phmap::priv::hash_default_eq<Key>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const Key, Value>>> // alias for std::allocator
+        class node_hash_map;
+
+    template <class T,
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_flat_hash_set;
+
+    template <class K, class V,
+              class Hash  = phmap::priv::hash_default_hash<K>,
+              class Eq    = phmap::priv::hash_default_eq<K>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const K, V>>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_flat_hash_map;
+
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_node_hash_set;
+
+    template <class Key, class Value,
+              class Hash  = phmap::priv::hash_default_hash<Key>,
+              class Eq    = phmap::priv::hash_default_eq<Key>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const Key, Value>>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_node_hash_map;
+
+    // ------------- forward declarations for btree containers ----------------------------------
+    template <typename Key, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<Key>>
+        class btree_set;
+
+    template <typename Key, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<Key>>
+        class btree_multiset;
+
+    template <typename Key, typename Value, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<phmap::priv::Pair<const Key, Value>>>
+        class btree_map;
+    
+    template <typename Key, typename Value, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<phmap::priv::Pair<const Key, Value>>>
+        class btree_multimap;
+
+}  // namespace phmap
+
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_fwd_decl_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_utils.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_utils.h
new file mode 100644
index 00000000..dcf1cb77
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/parallel_hashmap/phmap_utils.h
@@ -0,0 +1,417 @@
+#if !defined(phmap_utils_h_guard_)
+#define phmap_utils_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+//       minimal header providing phmap::HashState
+//
+//       use as:  phmap::HashState().combine(0, _first_name, _last_name, _age);
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+#endif
+
+#include <cstdint>
+#include <functional>
+#include <tuple>
+#include "phmap_bits.h"
+
+// ---------------------------------------------------------------
+// Absl forward declaration requires global scope.
+// ---------------------------------------------------------------
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(phmap_fwd_decl_h_guard_) && !defined(ABSL_HASH_HASH_H_)
+    namespace absl { template <class T> struct Hash; };
+#endif
+
+namespace phmap
+{
+
+// ---------------------------------------------------------------
+// ---------------------------------------------------------------
+template<int n> 
+struct phmap_mix
+{
+    inline size_t operator()(size_t) const;
+};
+
+template<>
+struct phmap_mix<4>
+{
+    inline size_t operator()(size_t a) const
+    {
+        static constexpr uint64_t kmul = 0xcc9e2d51UL;
+        // static constexpr uint64_t kmul = 0x3B9ACB93UL; // [greg] my own random prime
+        uint64_t l = a * kmul;
+        return static_cast<size_t>(l ^ (l >> 32));
+    }
+};
+
+#if defined(PHMAP_HAS_UMUL128)
+    template<>
+    struct phmap_mix<8>
+    {
+        // Very fast mixing (similar to Abseil)
+        inline size_t operator()(size_t a) const
+        {
+            static constexpr uint64_t k = 0xde5fb9d2630458e9ULL;
+            // static constexpr uint64_t k = 0x7C9D0BF0567102A5ULL; // [greg] my own random prime
+            uint64_t h;
+            uint64_t l = umul128(a, k, &h);
+            return static_cast<size_t>(h + l);
+        }
+    };
+#else
+    template<>
+    struct phmap_mix<8>
+    {
+        inline size_t operator()(size_t a) const
+        {
+            a = (~a) + (a << 21); // a = (a << 21) - a - 1;
+            a = a ^ (a >> 24);
+            a = (a + (a << 3)) + (a << 8); // a * 265
+            a = a ^ (a >> 14);
+            a = (a + (a << 2)) + (a << 4); // a * 21
+            a = a ^ (a >> 28);
+            a = a + (a << 31);
+            return static_cast<size_t>(a);
+        }
+    };
+#endif
+
+// --------------------------------------------
+template<int n> 
+struct fold_if_needed
+{
+    inline size_t operator()(uint64_t) const;
+};
+
+template<>
+struct fold_if_needed<4>
+{
+    inline size_t operator()(uint64_t a) const
+    {
+        return static_cast<size_t>(a ^ (a >> 32));
+    }
+};
+
+template<>
+struct fold_if_needed<8>
+{
+    inline size_t operator()(uint64_t a) const
+    {
+        return static_cast<size_t>(a);
+    }
+};
+
+// ---------------------------------------------------------------
+// see if class T has a hash_value() friend method
+// ---------------------------------------------------------------
+template<typename T>
+struct has_hash_value
+{
+private:
+    typedef std::true_type yes;
+    typedef std::false_type no;
+
+    template<typename U> static auto test(int) -> decltype(hash_value(std::declval<const U&>()) == 1, yes());
+
+    template<typename> static no test(...);
+
+public:
+    static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
+};
+
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(phmap_fwd_decl_h_guard_)
+    template <class T> using Hash = ::absl::Hash<T>;
+#elif !defined(PHMAP_USE_ABSL_HASH)
+// ---------------------------------------------------------------
+//               phmap::Hash
+// ---------------------------------------------------------------
+template <class T>
+struct Hash
+{
+    template <class U, typename std::enable_if<has_hash_value<U>::value, int>::type = 0>
+    size_t _hash(const T& val) const
+    {
+        return hash_value(val);
+    }
+ 
+    template <class U, typename std::enable_if<!has_hash_value<U>::value, int>::type = 0>
+    size_t _hash(const T& val) const
+    {
+        return std::hash<T>()(val);
+    }
+ 
+    inline size_t operator()(const T& val) const
+    {
+        return _hash<T>(val);
+    }
+};
+ 
+template<class ArgumentType, class ResultType>
+struct phmap_unary_function
+{
+    typedef ArgumentType argument_type;
+    typedef ResultType result_type;
+};
+
+template <>
+struct Hash<bool> : public phmap_unary_function<bool, size_t>
+{
+    inline size_t operator()(bool val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<char> : public phmap_unary_function<char, size_t>
+{
+    inline size_t operator()(char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<signed char> : public phmap_unary_function<signed char, size_t>
+{
+    inline size_t operator()(signed char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<unsigned char> : public phmap_unary_function<unsigned char, size_t>
+{
+    inline size_t operator()(unsigned char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+#ifdef PHMAP_HAS_NATIVE_WCHAR_T
+template <>
+struct Hash<wchar_t> : public phmap_unary_function<wchar_t, size_t>
+{
+    inline size_t operator()(wchar_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+#endif
+
+template <>
+struct Hash<int16_t> : public phmap_unary_function<int16_t, size_t>
+{
+    inline size_t operator()(int16_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<uint16_t> : public phmap_unary_function<uint16_t, size_t>
+{
+    inline size_t operator()(uint16_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<int32_t> : public phmap_unary_function<int32_t, size_t>
+{
+    inline size_t operator()(int32_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<uint32_t> : public phmap_unary_function<uint32_t, size_t>
+{
+    inline size_t operator()(uint32_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<int64_t> : public phmap_unary_function<int64_t, size_t>
+{
+    inline size_t operator()(int64_t val) const noexcept
+    { return fold_if_needed<sizeof(size_t)>()(static_cast<uint64_t>(val)); }
+};
+
+template <>
+struct Hash<uint64_t> : public phmap_unary_function<uint64_t, size_t>
+{
+    inline size_t operator()(uint64_t val) const noexcept
+    { return fold_if_needed<sizeof(size_t)>()(val); }
+};
+
+template <>
+struct Hash<float> : public phmap_unary_function<float, size_t>
+{
+    inline size_t operator()(float val) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint32_t *as_int = reinterpret_cast<uint32_t *>(&val);
+        return (val == 0) ? static_cast<size_t>(0) : 
+                            static_cast<size_t>(*as_int);
+    }
+};
+
+template <>
+struct Hash<double> : public phmap_unary_function<double, size_t>
+{
+    inline size_t operator()(double val) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint64_t *as_int = reinterpret_cast<uint64_t *>(&val);
+        return (val == 0) ? static_cast<size_t>(0) : 
+                            fold_if_needed<sizeof(size_t)>()(*as_int);
+    }
+};
+
+#endif
+
+#if defined(_MSC_VER)
+#   define PHMAP_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#   define PHMAP_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
+
+template <class H, int sz> struct Combiner
+{
+    H operator()(H seed, size_t value);
+};
+
+template <class H> struct Combiner<H, 4>
+{
+    H operator()(H h1, size_t k1)
+    {
+#if 1
+        // Copyright 2005-2014 Daniel James.
+        // Distributed under the Boost Software License, Version 1.0. (See accompanying
+        // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+        
+        const uint32_t c1 = 0xcc9e2d51;
+        const uint32_t c2 = 0x1b873593;
+
+        k1 *= c1;
+        k1 = PHMAP_HASH_ROTL32(k1,15);
+        k1 *= c2;
+
+        h1 ^= k1;
+        h1 = PHMAP_HASH_ROTL32(h1,13);
+        h1 = h1*5+0xe6546b64;
+
+        return h1;
+#else
+        return h1 ^ (k1 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
+#endif
+    }
+};
+
+template <class H> struct Combiner<H, 8>
+{
+    H operator()(H h, size_t k)
+    {
+#if 1
+        // Copyright 2005-2014 Daniel James.
+        // Distributed under the Boost Software License, Version 1.0. (See accompanying
+        // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+        const uint64_t m = (uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
+        const int r = 47;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+
+        // Completely arbitrary number, to prevent 0's
+        // from hashing to 0.
+        h += 0xe6546b64;
+
+        return h;
+#else
+        return h ^ (k + size_t(0xc6a4a7935bd1e995) + (h << 6) + (h >> 2));
+#endif
+    }
+};
+
+// define HashState to combine member hashes... see example below
+// -----------------------------------------------------------------------------
+template <typename H>
+class HashStateBase {
+public:
+    template <typename T, typename... Ts>
+    static H combine(H state, const T& value, const Ts&... values);
+
+    static H combine(H state) { return state; }
+};
+
+template <typename H>
+template <typename T, typename... Ts>
+H HashStateBase<H>::combine(H seed, const T& v, const Ts&... vs)
+{
+    return HashStateBase<H>::combine(Combiner<H, sizeof(H)>()(
+                                         seed, phmap::Hash<T>()(v)), 
+                                     vs...);
+}
+
+using HashState = HashStateBase<size_t>;
+
+// -----------------------------------------------------------------------------
+
+#if !defined(PHMAP_USE_ABSL_HASH)
+
+// define Hash for std::pair
+// -------------------------
+template<class T1, class T2> 
+struct Hash<std::pair<T1, T2>> {
+    size_t operator()(std::pair<T1, T2> const& p) const noexcept {
+        return phmap::HashState().combine(phmap::Hash<T1>()(p.first), p.second);
+    }
+};
+
+// define Hash for std::tuple
+// --------------------------
+template<class... T> 
+struct Hash<std::tuple<T...>> {
+    size_t operator()(std::tuple<T...> const& t) const noexcept {
+        size_t seed = 0;
+        return _hash_helper(seed, t);
+    }
+
+private:
+    template<size_t I = 0, class TUP>
+    typename std::enable_if<I == std::tuple_size<TUP>::value, size_t>::type
+    _hash_helper(size_t seed, const TUP &) const noexcept { return seed; }
+
+    template<size_t I = 0, class TUP>
+    typename std::enable_if<I < std::tuple_size<TUP>::value, size_t>::type
+    _hash_helper(size_t seed, const TUP &t) const noexcept {
+        const auto &el = std::get<I>(t);
+        using el_type = typename std::remove_cv<typename std::remove_reference<decltype(el)>::type>::type;
+        seed = Combiner<size_t, sizeof(size_t)>()(seed, phmap::Hash<el_type>()(el));
+        return _hash_helper<I + 1>(seed, t);
+    }
+};
+
+
+#endif
+
+
+}  // namespace phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_utils_h_guard_
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_bound_malloc.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_bound_malloc.h
new file mode 100644
index 00000000..0d6b9410
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_bound_malloc.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+#define SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+
+#include <cstddef>
+#include <cstdint>
+namespace slamp 
+{
+
+void init_bound_malloc(void* heap_bound);
+void fini_bound_malloc();
+
+size_t get_object_size(void* ptr);
+
+void* bound_malloc(size_t size, size_t alignment=16);
+bool bound_free(void *ptr, uint64_t &starting_page, unsigned &purge_cnt);
+void* bound_calloc(size_t num, size_t size);
+void* bound_realloc(void* ptr, size_t size);
+void  bound_discard_page();
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_logger.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_logger.h
new file mode 100644
index 00000000..89641a03
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_logger.h
@@ -0,0 +1,110 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_LOGGER
+#define SLAMPLIB_HOOKS_SLAMP_LOGGER
+
+#include <cstdint>
+#include <stdint.h>
+#include <stdlib.h>
+#include <functional>
+
+#include "slamp_timestamp.h"
+
+namespace slamp
+{
+
+struct KEY
+{
+  uint32_t src;
+  uint32_t dst;
+  uint32_t dst_bare;
+  uint32_t cross;
+
+  KEY() {}
+  KEY(uint32_t s, uint32_t d, uint32_t b, uint32_t c) : src(s), dst(d), dst_bare(b), cross(c) {}
+};
+
+struct KEYHash
+{
+  size_t operator()(const KEY& key) const
+  {
+    static_assert(sizeof(size_t) == sizeof(uint64_t), "Should be 64bit address");
+    std::hash<uint64_t> hash_fn;
+
+    // hash(32-32) ^ hash(32-1)
+    // FIXME: find a better hash function
+    return hash_fn(((uint64_t)key.src << 32) | key.dst) ^ hash_fn(((uint64_t)key.dst_bare << 1) | (key.cross & 0x1));
+  }
+};
+
+struct KEYComp
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if (src1 < src2)
+      return true;
+    else if (src1 > src2)
+      return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if (dst1 < dst2)
+      return true;
+    else if (dst1 > dst2)
+      return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if (dst_bare1 < dst_bare2)
+      return true;
+    else if (dst_bare1 > dst_bare2)
+      return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    return cross1 < cross2;
+  }
+};
+
+struct KEYEqual
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if ( src1 != src2 ) return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if ( dst1 != dst2 ) return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if ( dst_bare1 != dst_bare2 ) return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    if ( cross1 != cross2 ) return false;
+
+    return true;
+  }
+};
+
+
+void init_logger(uint32_t fn_id, uint32_t loop_id);
+void fini_logger(const char* filename);
+
+uint32_t log(TS ts, const uint32_t dst_instr, TS* pts, const uint32_t bare_inst, uint64_t addr, uint64_t value, uint8_t size);
+void print_log(const char* filename);
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_shadow_mem.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_shadow_mem.h
new file mode 100644
index 00000000..9aeffbb2
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_shadow_mem.h
@@ -0,0 +1,250 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+#define SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+
+#include <cassert>
+#include <csignal>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <set>
+#include <unordered_map>
+
+// higher half of canonical region cannot be used
+
+/// left shift by `shift`, mask 47 LSB, toggle #45 bit?
+#define MASK1 0x00007fffffffffffL
+#define MASK2 0x0000200000000000L
+#define MASK2_PT 0x0000100000000000L
+#define MASK2_OL 0x0000400000000000L
+#define GET_SHADOW(addr, shift)                                                \
+  (((((uint64_t)(addr)) << (shift)) & MASK1) ^ MASK2)
+#define GET_SHADOW_PT(addr, shift)                                                \
+  (((((uint64_t)(addr)) << (shift)) & MASK1) ^ MASK2_PT)
+#define GET_SHADOW_OL(addr, shift)                                                \
+  (((((uint64_t)(addr)) << (shift)) & MASK1) ^ MASK2_OL)
+
+namespace slamp {
+
+template <uint64_t MASK2_VAL=MASK2>
+class MemoryMap {
+private:
+  inline uint64_t get_shadow(uint64_t addr, uint64_t shift) {
+    return (((addr << shift) & MASK1) ^ MASK2_VAL);
+  }
+  // TODO: fix this redundant info as the LocalWriteModule
+  const uint32_t LOCALWRITE_MASK{};
+  const uint32_t LOCALWRITE_PATTERN{};
+  static constexpr uint32_t LOCALWRITE_SHIFT = 12; // PAGE SIZE 4096 = 2^12
+
+  bool local_write_cond(uint64_t addr) {
+    if (((addr >> LOCALWRITE_SHIFT) & LOCALWRITE_MASK) == LOCALWRITE_PATTERN)
+      return true;
+    return false;
+  }
+
+public:
+  uint64_t heapStart = 0;
+  MemoryMap(uint32_t mask, uint32_t pattern, unsigned r)
+      : LOCALWRITE_MASK(mask), LOCALWRITE_PATTERN(pattern), ratio(r), ratio_shift(0)  {
+    // ratio expected to be a power of 2
+    assert((r & (r - 1)) == 0);
+
+    // log(r)
+    unsigned n = r;
+    while ((n & 1) == 0) {
+      this->ratio_shift += 1;
+      n = n >> 1;
+    }
+
+    // get the page size of the host system
+    pagesize = getpagesize();
+    pagemask = ~(pagesize - 1);
+  }
+
+  ~MemoryMap() {
+    // freeing all remaining shadow addresses
+    for (auto page : pages) {
+      if (!local_write_cond(page))
+        continue;
+      uint64_t s = get_shadow(page, ratio_shift);
+      munmap(reinterpret_cast<void *>(s), pagesize * ratio);
+    }
+  }
+
+  unsigned get_ratio() { return ratio; }
+
+  bool is_allocated(void *addr) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t page = a & pagemask;
+    if (pages.find(page) != pages.end())
+      return true;
+    else
+      return false;
+  }
+
+  /// allocate shadow page if not exist
+  void *allocate(void *addr, size_t size) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t pagebegin = a & pagemask;
+    uint64_t pageend = (a + size - 1) & pagemask;
+
+    // try mmap
+
+    std::set<void *> shadow_pages;
+    bool success = true;
+
+    for (uint64_t page = pagebegin; page <= pageend; page += pagesize) {
+      if (!local_write_cond(page))
+        continue;
+      if (pages.find(page) != pages.end())
+        continue;
+
+      uint64_t s = get_shadow(page, ratio_shift);
+      // create a shadow page for the page
+      void *p = mmap(reinterpret_cast<void *>(s), pagesize * ratio,
+                     PROT_WRITE | PROT_READ,
+                     // So do not replace the orignal program memory by accident
+                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0);
+                     // MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+      if (p == MAP_FAILED) {
+        int err = errno;
+        // if (err == EEXIST) {
+          // shadow_pages.insert(reinterpret_cast<void *>(s));
+        // } else {
+          printf("mmap failed: %lx errno: %d\n", s, err);
+          raise(SIGINT);
+
+          success = false;
+          break;
+        // }
+      } else {
+        shadow_pages.insert(p);
+      }
+    }
+
+    if (success) {
+      for (uint64_t page = pagebegin; page <= pageend; page += pagesize)
+        pages.insert(page);
+      uint64_t pagebegin = a & pagemask;
+      uint64_t pageend = (a + size - 1) & pagemask;
+
+      // return shadow_mem
+      auto *shadow_addr = (uint64_t *)get_shadow(a, ratio_shift);
+      return (void *)(shadow_addr);
+    } else {
+      // cleanup
+      for (auto shadow_page : shadow_pages)
+        munmap(shadow_page, pagesize * ratio);
+      return nullptr;
+    }
+  }
+
+  // free the shadow pages
+  void deallocate_pages(uint64_t page, unsigned cnt) {
+    munmap(reinterpret_cast<void *>(get_shadow(page, ratio_shift)),
+           pagesize * ratio * cnt);
+
+    // fprintf(stderr, "deallocate_pages: %lx %d\n", get_shadow(page, ratio_shift), cnt);
+
+    for (auto i = 0; i < cnt; i++, page += pagesize)
+      pages.erase(page);
+  }
+
+  /// for realloc; the dependence carries over
+  void copy(void *dst, void *src, size_t size) {
+    size_t shadow_size = size * ratio;
+    void *shadow_dst = (void *)get_shadow(dst, ratio_shift);
+    void *shadow_src = (void *)get_shadow(src, ratio_shift);
+    memcpy(shadow_dst, shadow_src, shadow_size);
+  }
+
+  void init_heap(void *addr) {
+    heapStart = reinterpret_cast<uint64_t>(addr);
+  }
+
+  // init stack size to be fixed 8MB
+  // the stack in /proc/$pid/maps changes in runtime, use it to find the end
+  void init_stack(uint64_t stack_size, uint64_t pid) {
+    char filename[256];
+    char buf[5000];
+    sprintf(filename, "/proc/%lu/maps", pid);
+    // sprintf(filename, "/proc/%u/maps", getpid());
+
+    FILE *fp = fopen(filename, "r");
+    if (!fp) {
+      perror(filename);
+      exit(EXIT_FAILURE);
+    }
+
+    bool allocated = false;
+
+    bool after_lib = false;
+    while (fgets(buf, sizeof(buf), fp) != nullptr) {
+      uint64_t start, end;
+      char name[5000];
+
+      int n = sscanf(buf, "%lx-%lx %*c%*c%*c%*c %*llx %*x:%*x %*lu %s", &start,
+                     &end, name);
+
+      if (n != 3) {
+        // if n == 2, could be the anonymous mapping after lib
+        // FIXME: double check this
+        if (n == 2 && after_lib) {
+          allocated = true;
+          allocate(reinterpret_cast<void *>(start), end - start);
+        }
+        continue;
+      }
+      after_lib = false;
+
+      // FIXME: get heap start addr
+      if (!strcmp(name, "[heap]")) {
+        heapStart = start;
+      }
+
+
+      if (!strcmp(name, "[stack]")) {
+        // stack grow from end (big address) backwards
+        // print the stack start and end
+        printf("stack: %lx %lx\n", end - stack_size, end);
+        allocate(reinterpret_cast<void *>(end - stack_size), stack_size);
+        allocated = true;
+        break;
+      }
+
+      // if contains libxxx.so, then allocate
+      if (strstr(name, ".so")) {
+        allocate(reinterpret_cast<void *>(start), end - start);
+        after_lib = true;
+        continue;
+      }
+
+      // locale
+      if (strstr(name, "locale")) {
+        allocate(reinterpret_cast<void *>(start), end - start);
+      }
+    }
+
+    if (!allocated) {
+      fprintf(stderr, "Error: failed to allocate shadow for stack");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+private:
+  std::set<uint64_t> pages; // page table
+
+  unsigned ratio; // (size of metadata) / (size of real data)
+  unsigned ratio_shift;
+  uint64_t pagesize;
+  uint64_t pagemask;
+};
+
+} // namespace slamp
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_timestamp.h b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_timestamp.h
new file mode 100644
index 00000000..80aac87f
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/ProfilingModules/slamp_timestamp.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+#define SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+
+#include <stdint.h>
+
+typedef uint64_t TS; // first 20 bits for instr and following 44 bits for iter
+#define TIMESTAMP_SIZE_IN_BYTES 8
+#define TIMESTAMP_SIZE_IN_POWER_OF_TWO 3
+#define ITERATION_SIZE 28 
+#define INVOCATION_SIZE 16 // 44-40
+#define CREATE_TS(instr, iter, invoc) ( ((TS)instr << 44) | (((TS)iter & (TS)0xfffffff) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xffff))
+#define CREATE_TS_HASH(instr, hash, iter, invoc)                               \
+  (((TS)instr << 44) |                                                         \
+   (((TS)hash & (TS)0xfffffffff) << 8) |                   \
+   (((TS)iter & (TS)0xf) << 4) | ((TS)invoc & (TS)0xf))
+#define GET_INSTR(ts) ((ts >> 44) & 0xfffff)
+#define GET_HASH(ts) ( (ts >> 8) & 0xfffffffff)
+#define GET_ITER(ts) ( (ts >> INVOCATION_SIZE) & 0xfffffff)
+#define GET_INVOC(ts) ( ts & 0xffff)
+
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPcustom/consumer/consumer.cpp b/liberty/lib/SLAMP/SLAMPcustom/consumer/consumer.cpp
new file mode 100644
index 00000000..d8617701
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/consumer/consumer.cpp
@@ -0,0 +1,1118 @@
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <chrono>
+#include <cstdint>
+#include <iostream>
+#include <sstream>
+#include <xmmintrin.h>
+
+#include "ProfilingModules/DependenceModule.h"
+#include "ProfilingModules/PointsToModule.h"
+#include "ProfilingModules/LoadedValueModule.h"
+#include "ProfilingModules/ObjectLifetimeModule.h"
+#include "sw_queue_astream.h"
+
+#define ATTRIBUTE(x) __attribute__((x))
+namespace bip = boost::interprocess;
+
+static inline uint64_t rdtsc() {
+  uint64_t a, d;
+  __asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
+  return (d << 32) | a;
+}
+
+#define DEBUG 0
+#define ACTION 1
+#define MEASURE_TIME 0
+
+// #define UNIFIED_WORKFLOW 1
+enum class UnifiedAction : char {
+  INIT = 0,
+  LOAD,
+  STORE,
+  ALLOC,
+  FREE,
+  LOOP_INVOC,
+  LOOP_ITER,
+  LOOP_ENTRY,
+  LOOP_EXIT,
+  LOOP_ITER_CTX,
+  FUNC_ENTRY,
+  FUNC_EXIT,
+  POINTS_TO_INST,
+  POINTS_TO_ARG,
+  FINISHED
+};
+
+// #define COLLECT_TRACE_EVENT
+#ifdef COLLECT_TRACE_EVENT
+#include <xmmintrin.h>
+#include <smmintrin.h>
+std::vector<__m128i> event_trace;
+static constexpr unsigned event_trace_size = 10'000'000;
+unsigned event_trace_idx = 0;
+#endif
+
+enum AvailableModules {
+  DEPENDENCE_MODULE = 0,
+  POINTS_TO_MODULE = 1,
+  LOADED_VALUE_MODULE = 2,
+  OBJECT_LIFETIME_MODULE = 3,
+  NUM_MODULES = 4
+};
+
+constexpr AvailableModules MODULE = DEPENDENCE_MODULE;
+// set the thread count
+constexpr unsigned THREAD_COUNT = 8;
+
+// #define CONSUME         sq_consume(the_queue);
+
+static uint64_t load_time(0);
+static uint64_t store_time(0);
+static uint64_t alloc_time(0);
+
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+
+void consume_loop_lv(DoubleQueue &dq, LoadedValueModule &lvMod) ATTRIBUTE(noinline) {
+  uint64_t rdtsc_start = 0;
+  uint64_t counter = 0;
+  uint32_t loop_id;
+
+#ifdef UNIFIED_WORKFLOW
+  using Action = UnifiedAction;
+#else
+  using Action = LoadedValueModAction;
+#endif
+
+  // measure time with lambda action
+  auto measure_time = [](uint64_t &time, auto action) {
+    // measure time with rdtsc
+    if (MEASURE_TIME) {
+      uint64_t start = rdtsc();
+      action();
+      uint64_t end = rdtsc();
+      time += end - start;
+    }
+    else {
+      action();
+    }
+  };
+
+  bool finished = false;
+  while (true) {
+    dq.check();
+    uint32_t v;
+    v = dq.consumePacket();
+    counter++;
+
+    // convert v to action
+    auto action = static_cast<Action>(v);
+
+    switch (action) {
+    case Action::INIT: {
+      uint32_t pid;
+      // loop_id = (uint32_t)dq.consume();
+      // pid = (uint32_t)dq.consume();
+      dq.unpack_32_32(loop_id, pid);
+      rdtsc_start = rdtsc();
+
+      if (DEBUG) {
+        std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+      }
+      if (ACTION) {
+        lvMod.init(loop_id, pid);
+      }
+      break;
+    };
+    case Action::LOAD: {
+      uint32_t instr;
+      uint64_t addr = 0;
+      uint64_t value = 0;
+
+      // uint32_t bare_instr;
+      uint32_t size = 0;
+
+      dq.unpack_32_64(instr, value);
+      lvMod.load(instr, addr, instr, value, size);
+#ifdef UNIFIED_WORKFLOW
+      dq.unpack_32_64(instr, addr);
+      dq.check();
+      dq.consumePacket();
+      dq.unpack_64(value);
+#else
+      dq.unpack_32_64(instr, value);
+#endif
+      lvMod.load(instr, addr, instr, value, size);
+
+      break;
+    };
+#ifdef UNIFIED_WORKFLOW
+    case Action::STORE:
+    case Action::ALLOC:
+    case Action::FREE:
+    case Action::LOOP_INVOC:
+    case Action::LOOP_ITER:
+    case Action::LOOP_ENTRY:
+    case Action::LOOP_EXIT:
+    case Action::LOOP_ITER_CTX:
+    case Action::FUNC_ENTRY:
+    case Action::FUNC_EXIT:
+    case Action::POINTS_TO_INST:
+    case Action::POINTS_TO_ARG:
+      break;
+#endif
+    case Action::FINISHED: {
+      uint64_t rdtsc_end = rdtsc();
+      // total cycles
+      uint64_t total_cycles = rdtsc_end - rdtsc_start;
+      std::cout << "Finished loop: " << loop_id << " after " << counter
+                << " events" << std::endl;
+      // print time in seconds
+      std::cout << "Total time: " << total_cycles / 2.6e9 << " s" << std::endl;
+      if (MEASURE_TIME) {
+        std::cout << "Load time: " << load_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Store time: " << store_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Alloc time: " << alloc_time / 2.6e9 << " s" << std::endl;
+      }
+      finished = true;
+
+      // if (ACTION) {
+        // lvMod.fini("ptlog.txt");
+      // }
+
+      break;
+    };
+    default:
+      std::cout << "Unknown action: " << (uint64_t)v << std::endl;
+
+      std::cout << "Is ready to read?:" << dq.qNow->ready_to_read << " "
+                << "Is ready to write?:" << dq.qNow->ready_to_write << std::endl;
+      std::cout << "Index: " << dq.index << " Size:" << dq.qNow->size << std::endl;
+
+      for (int i = 0; i < 101; i++) {
+        std::cout << dq.qNow->data[dq.index - 100 + i] << " ";
+      }
+      exit(-1);
+    }
+
+    // if (counter % 100'000'000 == 0) {
+      // std::cout << "Processed " << counter / 1'000'000 << "M events" << std::endl;
+    // }
+    if (finished) {
+      break;
+    }
+  }
+}
+
+void consume_loop_ol(DoubleQueue &dq, ObjectLifetimeModule &olMod) ATTRIBUTE(noinline) {
+  uint64_t rdtsc_start = 0;
+  uint64_t counter = 0;
+  uint32_t loop_id;
+
+#ifdef UNIFIED_WORKFLOW
+  using Action = UnifiedAction;
+#else
+  using Action = ObjectLifetimeModAction;
+#endif
+  // measure time with lambda action
+  auto measure_time = [](uint64_t &time, auto action) {
+    // measure time with rdtsc
+    if (MEASURE_TIME) {
+      uint64_t start = rdtsc();
+      action();
+      uint64_t end = rdtsc();
+      time += end - start;
+    }
+    else {
+      action();
+    }
+  };
+
+  bool finished = false;
+  while (true) {
+    dq.check();
+    uint32_t v;
+    v = dq.consumePacket();
+    counter++;
+
+    // convert v to action
+    auto action = static_cast<Action>(v);
+
+    switch (action) {
+    case Action::INIT: {
+      uint32_t pid;
+      // loop_id = (uint32_t)dq.consume();
+      // pid = (uint32_t)dq.consume();
+      dq.unpack_32_32(loop_id, pid);
+      rdtsc_start = rdtsc();
+
+      if (DEBUG) {
+        std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+      }
+      if (ACTION) {
+        olMod.init(loop_id, pid);
+      }
+      break;
+    };
+    case Action::ALLOC: {
+      uint32_t instr;
+      uint64_t addr;
+      uint32_t size;
+      dq.unpack_24_32_64(instr, size, addr);
+
+      if (DEBUG) {
+        std::cout << "ALLOC: " << addr << " " << size << std::endl;
+      }
+      if (ACTION) {
+        measure_time(alloc_time, [&]() {
+          olMod.allocate(reinterpret_cast<void *>(addr), instr, size);
+        });
+      }
+      break;
+    };
+    case Action::FREE: {
+      uint64_t addr;
+      dq.unpack_64(addr);
+
+      if (DEBUG) {
+        std::cout << "FREE: " << addr << std::endl;
+      }
+      if (ACTION) {
+        measure_time(alloc_time,
+            [&]() { olMod.free(reinterpret_cast<void *>(addr)); });
+      }
+      break;
+    };
+    case Action::LOOP_INVOC: {
+      if (DEBUG) {
+        std::cout << "LOOP_INVOC" << std::endl;
+      }
+
+      if (ACTION) {
+        olMod.loop_invoc();
+      }
+      break;
+    };
+    case Action::LOOP_ITER: {
+      if (DEBUG) {
+        std::cout << "LOOP_ITER" << std::endl;
+      }
+      if (ACTION) {
+        olMod.loop_iter();
+      }
+      break;
+    };
+    case Action::LOOP_EXIT: {
+      if (DEBUG) {
+        std::cout << "LOOP_EXIT " << std::endl;
+      }
+      if (ACTION) {
+        olMod.loop_exit();
+      }
+      break;
+    };
+    case Action::FUNC_ENTRY: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      if (DEBUG) {
+        std::cout << "FUNC_ENTRY: " << func_id << std::endl;
+      }
+      if (ACTION) {
+        olMod.func_entry(func_id);
+      }
+      break;
+    };
+    case Action::FUNC_EXIT: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      if (DEBUG) {
+        std::cout << "FUNC_EXIT: " << func_id << std::endl;
+      }
+      if (ACTION) {
+        olMod.func_exit(func_id);
+      }
+      break;
+    };
+#ifdef UNIFIED_WORKFLOW
+    case Action::LOAD:
+      dq.check();
+      dq.consumePacket();
+      break;
+    case Action::STORE:
+    case Action::LOOP_ENTRY:
+    case Action::LOOP_ITER_CTX:
+    case Action::POINTS_TO_INST:
+    case Action::POINTS_TO_ARG:
+      break;
+#endif
+    case Action::FINISHED: {
+      uint64_t rdtsc_end = rdtsc();
+      // total cycles
+      uint64_t total_cycles = rdtsc_end - rdtsc_start;
+      std::cout << "Finished loop: " << loop_id << " after " << counter
+                << " events" << std::endl;
+      // print time in seconds
+      std::cout << "Total time: " << total_cycles / 2.6e9 << " s" << std::endl;
+      if (MEASURE_TIME) {
+        std::cout << "Load time: " << load_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Store time: " << store_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Alloc time: " << alloc_time / 2.6e9 << " s" << std::endl;
+      }
+      finished = true;
+
+      if (ACTION) {
+        olMod.fini("ollog.txt");
+      }
+
+      break;
+    };
+    default:
+      std::cout << "Unknown action: " << (uint64_t)v << std::endl;
+
+      std::cout << "Is ready to read?:" << dq.qNow->ready_to_read << " "
+                << "Is ready to write?:" << dq.qNow->ready_to_write << std::endl;
+      std::cout << "Index: " << dq.index << " Size:" << dq.qNow->size << std::endl;
+
+      for (int i = 0; i < 101; i++) {
+        std::cout << dq.qNow->data[dq.index - 100 + i] << " ";
+      }
+      exit(-1);
+    }
+
+    // if (counter % 100'000'000 == 0) {
+      // std::cout << "Processed " << counter / 1'000'000 << "M events" << std::endl;
+    // }
+    if (finished) {
+      break;
+    }
+  }
+}
+
+void consume_loop_pt(DoubleQueue &dq, PointsToModule &ptMod) ATTRIBUTE(noinline) {
+  uint64_t rdtsc_start = 0;
+  uint64_t counter = 0;
+  uint32_t loop_id;
+
+#ifdef UNIFIED_WORKFLOW
+  using Action = UnifiedAction;
+#else
+  using Action = PointsToModAction;
+#endif
+  // measure time with lambda action
+  auto measure_time = [](uint64_t &time, auto action) {
+    // measure time with rdtsc
+    if (MEASURE_TIME) {
+      uint64_t start = rdtsc();
+      action();
+      uint64_t end = rdtsc();
+      time += end - start;
+    }
+    else {
+      action();
+    }
+  };
+
+  bool finished = false;
+  while (true) {
+    dq.check();
+    uint32_t v;
+    v = dq.consumePacket();
+    counter++;
+
+    // convert v to action
+    auto action = static_cast<Action>(v);
+
+    switch (action) {
+    case Action::INIT: {
+      uint32_t pid;
+      // loop_id = (uint32_t)dq.consume();
+      // pid = (uint32_t)dq.consume();
+      dq.unpack_32_32(loop_id, pid);
+      rdtsc_start = rdtsc();
+
+      if (DEBUG) {
+        std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+      }
+      if (ACTION) {
+        ptMod.init(loop_id, pid);
+      }
+      break;
+    };
+    case Action::ALLOC: {
+      uint32_t instr;
+      uint64_t addr;
+      uint32_t size;
+      dq.unpack_24_32_64(instr, size, addr);
+
+      if (DEBUG) {
+        std::cout << "ALLOC: " << addr << " " << size << std::endl;
+      }
+      if (ACTION) {
+        measure_time(alloc_time, [&]() {
+          ptMod.allocate(reinterpret_cast<void *>(addr), instr, size);
+        });
+      }
+      break;
+    };
+    case Action::FREE: {
+      uint64_t addr;
+      dq.unpack_64(addr);
+
+      if (DEBUG) {
+        std::cout << "FREE: " << addr << std::endl;
+      }
+      if (ACTION) {
+        measure_time(alloc_time,
+            [&]() { ptMod.free(reinterpret_cast<void *>(addr)); });
+      }
+      break;
+    };
+    case Action::LOOP_INVOC: {
+      if (DEBUG) {
+        std::cout << "LOOP_INVOC" << std::endl;
+      }
+
+      if (ACTION) {
+        ptMod.loop_invoc();
+      }
+      break;
+    };
+    case Action::LOOP_ITER: {
+      if (DEBUG) {
+        std::cout << "LOOP_ITER" << std::endl;
+      }
+      if (ACTION) {
+        ptMod.loop_iter();
+      }
+      break;
+    };
+    case Action::LOOP_ENTRY: {
+      uint32_t loop_id;
+      dq.unpack_32(loop_id);
+      if (DEBUG) {
+        std::cout << "LOOP_ENTRY: " << loop_id << std::endl;
+      }
+      if (ACTION) {
+        ptMod.loop_entry(loop_id);
+      }
+      break;
+    };
+    case Action::LOOP_EXIT: {
+      uint32_t loop_id;
+      dq.unpack_32(loop_id);
+      if (DEBUG) {
+        std::cout << "LOOP_EXIT: " << loop_id << std::endl;
+      }
+      if (ACTION) {
+        ptMod.loop_exit(loop_id);
+      }
+      break;
+    };
+    case Action::FUNC_ENTRY: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      if (DEBUG) {
+        std::cout << "FUNC_ENTRY: " << func_id << std::endl;
+      }
+      if (ACTION) {
+        ptMod.func_entry(func_id);
+      }
+      break;
+    };
+    case Action::FUNC_EXIT: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      if (DEBUG) {
+        std::cout << "FUNC_EXIT: " << func_id << std::endl;
+      }
+      if (ACTION) {
+        ptMod.func_exit(func_id);
+      }
+      break;
+    };
+
+    case Action::POINTS_TO_ARG: {
+      uint32_t fcnId;
+      uint32_t argId;
+      uint64_t addr;
+      dq.unpack_32_64(fcnId, addr);
+      // break fcnId into argId and fcnId, 16 bit each
+      argId = fcnId & 0xFFFF;
+      fcnId = fcnId >> 16;
+      if (DEBUG) {
+        std::cout << "POINTS_TO_ARG: " << fcnId << " " << argId << " " << addr
+                  << std::endl;
+      }
+
+      if (ACTION) {
+        ptMod.points_to_arg(fcnId, argId, reinterpret_cast<void *>(addr));
+      }
+      break;
+    };
+
+    case Action::POINTS_TO_INST: {
+      uint32_t instId;
+      uint64_t addr;
+      dq.unpack_32_64(instId, addr);
+      if (DEBUG) {
+        std::cout << "POINTS_TO_INST: " << instId << " " << addr << std::endl;
+      }
+      if (ACTION) {
+        ptMod.points_to_inst(instId, reinterpret_cast<void *>(addr));
+      }
+      break;
+    };
+#ifdef UNIFIED_WORKFLOW
+    case Action::LOAD:
+      dq.check();
+      dq.consumePacket();
+      break;
+    case Action::STORE:
+    case Action::LOOP_ITER_CTX:
+      break;
+#endif
+    case Action::FINISHED: {
+      uint64_t rdtsc_end = rdtsc();
+      // total cycles
+      uint64_t total_cycles = rdtsc_end - rdtsc_start;
+      std::cout << "Finished loop: " << loop_id << " after " << counter
+                << " events" << std::endl;
+      // print time in seconds
+      std::cout << "Total time: " << total_cycles / 2.6e9 << " s" << std::endl;
+      if (MEASURE_TIME) {
+        std::cout << "Load time: " << load_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Store time: " << store_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Alloc time: " << alloc_time / 2.6e9 << " s" << std::endl;
+      }
+      finished = true;
+
+      // if (ACTION) {
+        // ptMod.fini("ptlog.txt");
+      // }
+
+      break;
+    };
+    default:
+      std::cout << "Unknown action: " << (uint64_t)v << std::endl;
+
+      std::cout << "Is ready to read?:" << dq.qNow->ready_to_read << " "
+                << "Is ready to write?:" << dq.qNow->ready_to_write << std::endl;
+      std::cout << "Index: " << dq.index << " Size:" << dq.qNow->size << std::endl;
+
+      for (int i = 0; i < 101; i++) {
+        std::cout << dq.qNow->data[dq.index - 100 + i] << " ";
+      }
+      exit(-1);
+    }
+
+    // if (counter % 100'000'000 == 0) {
+      // std::cout << "Processed " << counter / 1'000'000 << "M events" << std::endl;
+    // }
+    if (finished) {
+      break;
+    }
+  }
+}
+
+void consume_loop(DoubleQueue &dq, DependenceModule &depMod) ATTRIBUTE(noinline) {
+  uint64_t rdtsc_start = 0;
+  uint64_t counter = 0;
+  uint32_t loop_id;
+
+#ifdef UNIFIED_WORKFLOW
+  using Action = UnifiedAction;
+#else
+  using Action = DepModAction;
+#endif
+  // measure time with lambda action
+  auto measure_time = [](uint64_t &time, auto action) {
+    // measure time with rdtsc
+    if (MEASURE_TIME) {
+      uint64_t start = rdtsc();
+      action();
+      uint64_t end = rdtsc();
+      time += end - start;
+    }
+    else {
+      action();
+    }
+  };
+
+  bool finished = false;
+  while (true) {
+    dq.check();
+    uint32_t v;
+    v = dq.consumePacket();
+    counter++;
+#ifdef COLLECT_TRACE_EVENT
+    if (event_trace_idx < event_trace_size) {
+      event_trace.push_back(dq.packet);
+      event_trace_idx++;
+    }
+#endif
+    auto action = static_cast<Action>(v);
+    switch (action) {
+    case Action::INIT: {
+      uint32_t pid;
+      // loop_id = (uint32_t)dq.consume();
+      // pid = (uint32_t)dq.consume();
+      dq.unpack_32_32(loop_id, pid);
+      rdtsc_start = rdtsc();
+
+      if (DEBUG) {
+        std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+      }
+      if (ACTION) {
+        depMod.init(loop_id, pid);
+      }
+      break;
+    };
+    case Action::LOAD: {
+      uint32_t instr;
+      uint64_t addr;
+      // uint32_t bare_instr;
+
+#ifdef UNIFIED_WORKFLOW
+      dq.unpack_32_64(instr, addr);
+      dq.check();
+      dq.consumePacket();
+      // dq.unpack_64(value);
+#else
+      dq.unpack_32_64(instr, addr);
+#endif
+
+      if (DEBUG) {
+        std::cout << "LOAD: " << instr << " " << addr // << " " << bare_instr
+                  << std::endl;
+      }
+      if (ACTION) {
+        measure_time(load_time,
+                     [&]() { depMod.load(instr, addr, instr); });
+                     // [&]() { depMod.load(instr, addr, bare_instr, value); });
+      }
+
+      break;
+    };
+    case Action::STORE: {
+      uint32_t instr;
+      // uint32_t bare_instr;
+      uint64_t addr;
+      dq.unpack_32_64(instr, addr);
+
+      if (DEBUG) {
+        std::cout << "STORE: " << instr << " " << addr // << " " << bare_instr
+                  << std::endl;
+      }
+      if (ACTION) {
+        measure_time(store_time,
+                     [&]() { depMod.store(instr, instr, addr); });
+                     // [&]() { depMod.store(instr, bare_instr, addr); });
+      }
+      break;
+    };
+    case Action::ALLOC: {
+      uint64_t addr;
+      uint32_t size;
+      dq.unpack_32_64(size, addr);
+
+      if (DEBUG) {
+        std::cout << "ALLOC: " << addr << " " << size << std::endl;
+      }
+      if (ACTION) {
+        measure_time(alloc_time, [&]() {
+          depMod.allocate(reinterpret_cast<void *>(addr), size);
+        });
+      }
+      break;
+    };
+    case Action::LOOP_INVOC: {
+      if (DEBUG) {
+        std::cout << "LOOP_INVOC" << std::endl;
+      }
+
+      if (ACTION) {
+        depMod.loop_invoc();
+      }
+      break;
+    };
+    case Action::LOOP_ITER: {
+      if (DEBUG) {
+        std::cout << "LOOP_ITER" << std::endl;
+      }
+      if (ACTION) {
+        depMod.loop_iter();
+      }
+      break;
+    };
+    case Action::FUNC_ENTRY: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      depMod.func_entry(func_id);
+      break;
+    };
+    case Action::FUNC_EXIT: {
+      uint32_t func_id;
+      dq.unpack_32(func_id);
+      depMod.func_exit(func_id);
+      break;
+    };
+    case Action::LOOP_EXIT: {
+      depMod.loop_exit();
+      break;
+    }
+#ifdef UNIFIED_WORKFLOW
+    case Action::FREE:
+    case Action::LOOP_ENTRY:
+    case Action::LOOP_ITER_CTX:
+    case Action::POINTS_TO_INST:
+    case Action::POINTS_TO_ARG:
+      break;
+#endif
+    case Action::FINISHED: {
+
+      // if (ACTION) {
+      //   std::stringstream ss;
+      //   ss << "deplog-" << loop_id << ".txt";
+      //   depMod.fini(ss.str().c_str());
+      // }
+
+      uint64_t rdtsc_end = rdtsc();
+      // total cycles
+      uint64_t total_cycles = rdtsc_end - rdtsc_start;
+      std::cout << "Finished loop: " << loop_id << " after " << counter
+                << " events" << std::endl;
+      // print time in seconds
+      std::cout << "Total time: " << total_cycles / 2.6e9 << " s" << std::endl;
+      if (MEASURE_TIME) {
+        std::cout << "Load time: " << load_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Store time: " << store_time / 2.6e9 << " s" << std::endl;
+        std::cout << "Alloc time: " << alloc_time / 2.6e9 << " s" << std::endl;
+      }
+      finished = true;
+
+      break;
+    };
+    default:
+      std::cout << "Unknown action: " << (uint64_t)v << std::endl;
+
+      std::cout << "Is ready to read?:" << dq.qNow->ready_to_read << " "
+                << "Is ready to write?:" << dq.qNow->ready_to_write << std::endl;
+      std::cout << "Index: " << dq.index << " Size:" << dq.qNow->size << std::endl;
+
+      for (int i = 0; i < 101; i++) {
+        std::cout << dq.qNow->data[dq.index - 100 + i] << " ";
+      }
+      exit(-1);
+    }
+
+    // if (counter % 100'000'000 == 0) {
+      // std::cout << "Processed " << counter / 1'000'000 << "M events" << std::endl;
+    // }
+    if (finished) {
+      break;
+    }
+  }
+
+#ifdef COLLECT_TRACE_EVENT
+  // dump the event trace to a binary file
+  std::ofstream event_trace_file("event_trace.bin", std::ios::binary);
+  event_trace_file.write((char *)event_trace.data(),
+                         event_trace.size() * sizeof(__m128i));
+  event_trace_file.close();
+#endif
+}
+
+int main(int argc, char** argv) {
+  char *env = getenv("SLAMP_QUEUE_ID");
+  if (env == NULL) {
+    std::cout << "SLAMP_QUEUE_ID not set" << std::endl;
+    exit(-1);
+  }
+  auto queue_name = std::string("slamp_queue_") + env;
+
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, queue_name.c_str(), sizeof(uint32_t) *QSIZE *4, (void*)(1UL << 32));
+  // print the address of the shared memory segment
+  std::cout << "Shared memory segment address: " << segment->get_address() << std::endl;
+
+  Queue_p dqA, dqB;
+  // double buffering
+  dqA = segment->construct<Queue>("DQ_A")(Queue());
+  dqB = segment->construct<Queue>("DQ_B")(Queue());
+  auto dataA = segment->construct<uint32_t>("DQ_Data_A")[QSIZE]();
+  auto dataB = segment->construct<uint32_t>("DQ_Data_B")[QSIZE]();
+
+  // find the first 16byte alignment 
+  dataA = (uint32_t*)(((uint64_t)dataA + 15) & ~15);
+  dataB = (uint32_t*)(((uint64_t)dataB + 15) & ~15);
+  dqA->init(dataA);
+  dqB->init(dataB);
+
+
+  constexpr unsigned MASK = THREAD_COUNT - 1;
+
+  unsigned running_threads= THREAD_COUNT;
+  std::mutex m;
+  std::condition_variable cv;
+
+  std::vector<std::thread> threads;
+  DoubleQueue *dqs[THREAD_COUNT];
+
+#ifdef UNIFIED_WORKFLOW
+  constexpr unsigned THREADS_DEP = 4;
+  constexpr unsigned THREADS_PT = 2; //4;
+  constexpr unsigned THREADS_LV = 4; //4;
+  constexpr unsigned THREADS_OL = 1; //1;
+  constexpr unsigned THREADS = THREADS_DEP + THREADS_PT + THREADS_LV + THREADS_OL;
+  running_threads = THREADS;
+  DoubleQueue *dqs_unified[THREADS];
+
+  DependenceModule *depMods[THREADS_DEP];
+  PointsToModule *ptMods[THREADS_PT];
+  LoadedValueModule *lvMods[THREADS_LV];
+  ObjectLifetimeModule *olMods[THREADS_OL];
+
+  auto thread_idx = 0;
+
+  std::cout << "Running in " << THREADS << " threads" << std::endl;
+
+  auto MASK_DEP = THREADS_DEP - 1;
+  for (unsigned i = 0; i < THREADS_DEP; i++) {
+    dqs_unified[thread_idx++] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+    depMods[i] = new DependenceModule(MASK_DEP, i);
+  }
+
+  auto MASK_PT = THREADS_PT - 1;
+  for (unsigned i = 0; i < THREADS_PT; i++) {
+    dqs_unified[thread_idx++] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+    ptMods[i] = new PointsToModule(MASK_PT, i);
+  }
+
+  auto MASK_LV = THREADS_LV - 1;
+  for (unsigned i = 0; i < THREADS_LV; i++) {
+    dqs_unified[thread_idx++] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+    lvMods[i] = new LoadedValueModule(MASK_LV, i);
+  }
+
+  auto MASK_OL = THREADS_OL - 1;
+  for (unsigned i = 0; i < THREADS_OL; i++) {
+    dqs_unified[thread_idx++] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+    olMods[i] = new ObjectLifetimeModule(MASK_OL, i);
+  }
+
+  thread_idx = 0;
+  for (unsigned i = 0; i < THREADS_DEP; i++) {
+    threads.emplace_back(std::thread(
+        [&](unsigned thread_id, unsigned id) {
+          consume_loop(*dqs_unified[thread_id], *depMods[id]);
+        },
+        thread_idx++, i));
+  }
+
+  for (unsigned i = 0; i < THREADS_PT; i++) {
+    threads.emplace_back(std::thread(
+        [&](unsigned thread_id, unsigned id) {
+          consume_loop_pt(*dqs_unified[thread_id], *ptMods[id]);
+        },
+        thread_idx++, i));
+  }
+
+  for (unsigned i = 0; i < THREADS_LV; i++) {
+    threads.emplace_back(std::thread(
+        [&](unsigned thread_id, unsigned id) {
+          consume_loop_lv(*dqs_unified[thread_id], *lvMods[id]);
+        },
+        thread_idx++, i));
+  }
+
+  for (unsigned i = 0; i < THREADS_OL; i++) {
+    threads.emplace_back(std::thread(
+        [&](unsigned thread_id, unsigned id) {
+          consume_loop_ol(*dqs_unified[thread_id], *olMods[id]);
+        },
+        thread_idx++, i));
+  }
+
+  for (auto &t : threads) {
+    t.join();
+  }
+
+  for (unsigned i = 0; i < THREADS_DEP; i++) {
+    if (i != 0) {
+      depMods[0]->merge_dep(*depMods[i]);
+    }
+  }
+
+  if (THREADS_DEP > 0) {
+    depMods[0]->fini("deplog.txt");
+  }
+
+  for (unsigned i = 0; i < THREADS_PT; i++) {
+    if (i != 0) {
+      ptMods[0]->merge(*ptMods[i]);
+    }
+  }
+
+  if (THREADS_PT > 0) {
+    ptMods[0]->fini("ptlog.txt");
+  }
+
+  for (unsigned i = 0; i < THREADS_LV; i++) {
+    if (i != 0) {
+      lvMods[0]->merge_values(*lvMods[i]);
+    }
+  }
+  if (THREADS_LV > 0) {
+    lvMods[0]->fini("lvlog.txt");
+  }
+
+  if (THREADS_OL > 0) {
+    olMods[0]->fini("ollog.txt");
+  }
+
+
+
+  // for (unsigned i = 0; i < THREADS_DEP; i++) {
+    // if (i != 0) {
+      // depMods[0]->merge_dep(*depMods[i]);
+    // }
+  // }
+  // if (THREADS_DEP > 0) {
+    // depMods[0]->fini("deplog.txt");
+  // }
+
+  // for (unsigned i = 0; i < THREADS_PT; i++) {
+    // if (i != 0) {
+      // ptMods[0]->merge(*ptMods[i]);
+    // }
+  // }
+  // if (THREADS_PT > 0) {
+    // ptMods[0]->fini("ptlog.txt");
+  // }
+  
+  // if (THREADS_OL > 0) {
+    // olMods[0]->fini("ollog.txt");
+  // }
+#else
+  if (MODULE == DEPENDENCE_MODULE) {
+    DependenceModule *depMods[THREAD_COUNT];
+
+    for (unsigned i = 0; i < THREAD_COUNT; i++) {
+      dqs[i] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+      depMods[i] = new DependenceModule(MASK, i);
+    }
+
+    if (THREAD_COUNT == 1) {
+      std::cout << "Running in main thread" << std::endl;
+      // single threaded, easy to debug
+      consume_loop(*dqs[0], *depMods[0]);
+
+      depMods[0]->fini("deplog.txt");
+    } else {
+      std::cout << "Running in " << THREAD_COUNT << " threads" << std::endl;
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        threads.emplace_back(std::thread(
+            [&](unsigned id) { consume_loop(*dqs[id], *depMods[id]); }, i));
+      }
+
+      for (auto &t : threads) {
+        t.join();
+      }
+
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        if (i != 0) {
+          depMods[0]->merge_dep(*depMods[i]);
+        }
+      }
+
+      depMods[0]->fini("deplog.txt");
+    }
+  }
+
+  if (MODULE == POINTS_TO_MODULE) {
+    PointsToModule *ptMods[THREAD_COUNT];
+
+    for (unsigned i = 0; i < THREAD_COUNT; i++) {
+      dqs[i] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+      // ptMods[i] = new PointsToModule(MASK, i);
+      ptMods[i] = new PointsToModule(MASK, i);
+    }
+
+    if (THREAD_COUNT == 1) {
+
+      std::cout << "Running in main thread" << std::endl;
+      // single threaded, easy to debug
+      consume_loop_pt(*dqs[0], *ptMods[0]);
+
+      // FIXME: hack!
+      ptMods[0]->decode_all();
+      ptMods[0]->fini("ptlog.txt");
+    } else {
+      std::cout << "Running in " << THREAD_COUNT << " threads" << std::endl;
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        threads.emplace_back(std::thread(
+            [&](unsigned id) { consume_loop_pt(*dqs[id], *ptMods[id]); }, i));
+      }
+
+      for (auto &t : threads) {
+        t.join();
+      }
+
+      // FIXME: hack!
+      ptMods[0]->decode_all();
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        if (i != 0) {
+          ptMods[0]->merge(*ptMods[i]);
+        }
+      }
+
+      ptMods[0]->fini("ptlog.txt");
+    }
+  }
+
+  if (MODULE == OBJECT_LIFETIME_MODULE) {
+    DoubleQueue dq(dqA, dqB, true, running_threads, m, cv);
+
+    ObjectLifetimeModule olMod(0, 0);
+    consume_loop_ol(dq, olMod);
+  }
+
+  if (MODULE == LOADED_VALUE_MODULE) {
+    LoadedValueModule *lvMods[THREAD_COUNT];
+    for (unsigned i = 0; i < THREAD_COUNT; i++) {
+      dqs[i] = new DoubleQueue(dqA, dqB, true, running_threads, m, cv);
+      lvMods[i] = new LoadedValueModule(MASK, i);
+    }
+
+    if (THREAD_COUNT == 1) {
+      std::cout << "Running in main thread" << std::endl;
+      // single threaded, easy to debug
+      consume_loop_lv(*dqs[0], *lvMods[0]);
+
+      lvMods[0]->fini("lvlog.txt");
+    } else {
+      std::cout << "Running in " << THREAD_COUNT << " threads" << std::endl;
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        threads.emplace_back(std::thread(
+            [&](unsigned id) { consume_loop_lv(*dqs[id], *lvMods[id]); }, i));
+      }
+
+      for (auto &t : threads) {
+        t.join();
+      }
+
+      for (unsigned i = 0; i < THREAD_COUNT; i++) {
+        if (i != 0) {
+          lvMods[0]->merge_values(*lvMods[i]);
+        }
+      }
+
+      lvMods[0]->fini("lvlog.txt");
+    }
+  }
+#endif
+
+  // remove the shared memory file
+  bip::shared_memory_object::remove(queue_name.c_str());
+}
diff --git a/liberty/lib/SLAMP/SLAMPcustom/inline.h b/liberty/lib/SLAMP/SLAMPcustom/inline.h
new file mode 100644
index 00000000..7b16986f
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/inline.h
@@ -0,0 +1,12 @@
+#ifndef INLINE_H
+#define INLINE_H
+
+#define Weak __attribute__((weak))
+
+#ifndef NO_INLINE
+#define Inline static inline
+#else /* NO_INLINE */
+#define Inline Weak
+#endif/* NO_INLINE */
+
+#endif /* INLINE_H */
diff --git a/liberty/lib/SLAMP/SLAMPcustom/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPcustom/slamp_hooks.h
new file mode 100644
index 00000000..b18efd38
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/slamp_hooks.h
@@ -0,0 +1,372 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void* SLAMP_realloc_hook(void *ptr, size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/SLAMPcustom/sw_queue.c b/liberty/lib/SLAMP/SLAMPcustom/sw_queue.c
new file mode 100644
index 00000000..33199929
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/sw_queue.c
@@ -0,0 +1,103 @@
+#include <assert.h>
+#include <stdio.h>
+
+#include "sw_queue_astream.h"
+
+/*
+ * Create and initialize a queue.
+ */
+SW_Queue sq_createQueue(void)
+{
+  return sq_initQueue(sq_createQueueBlock(1));
+}
+
+/*
+ * Creates, but does not initialize a block of queues.
+ */
+SW_Queue sq_createQueueBlock(unsigned queues) {
+
+  /* Allocate the queue data structure */
+  sw_queue_t *queue = (sw_queue_t *) mmap((void *) (1UL << 32),
+                                          queues * sizeof(sw_queue_t),
+                                          PROT_WRITE | PROT_READ,
+                                          MAP_SHARED | MAP_ANONYMOUS,
+                                          -1,
+                                          (off_t) 0);
+  if(queue == (sw_queue_t *) -1) {
+    perror("sq_createQueue");
+    exit(1);
+  }
+
+  return queue;
+}
+
+/*
+ * Initialize a queue. sq_createQueue does this automatically.
+ */
+SW_Queue sq_initQueue(SW_Queue queue) {
+  
+  /* Allocate the queue */
+  queue->data = (uint64_t *) mmap(0,
+                                  sizeof(uint64_t) * QSIZE,
+                                  PROT_WRITE | PROT_READ,
+                                  MAP_SHARED | MAP_ANONYMOUS | MAP_32BIT,
+                                  -1,
+                                  (off_t) 0);
+  
+  if(queue->data == (void *) -1) {
+    perror("sq_initQueue");
+    exit(1);
+  }
+
+  /* Initialize the queue data structure */
+  queue->p_data = (uint64_t) queue->data;
+  queue->c_inx = 0;
+  queue->c_margin = 0;
+  queue->p_glb_inx = 0;
+  queue->c_glb_inx = 0;
+  queue->ptr_c_glb_inx = &(queue->c_glb_inx);
+  queue->ptr_p_glb_inx = &(queue->p_glb_inx);
+
+#ifdef INSTRUMENT
+  queue->total_produces = 0;
+  queue->total_consumes = 0;
+#endif
+
+  return queue;  
+}
+
+void sq_freeQueueBlock(SW_Queue queue, unsigned size) {
+
+  for(unsigned i = 0; i < size; ++i) {
+
+    /* This queue may never have been initialized. */
+    if(queue[i].data) {
+      
+#ifdef INSTRUMENT
+      fprintf(stderr, "Queue %p: %ld produces, %ld consumes\n",
+              (void*)queue,
+              queue->total_produces,
+              queue->total_consumes);
+#endif
+
+      if(munmap(queue[i].data, sizeof(uint64_t) * QSIZE)) {
+        perror("sq_freeQueueBlock");
+        exit(-1);
+      }
+    }
+  }
+
+  if(munmap(queue, sizeof(sw_queue_t) * size)) {
+    perror("sq_freeQueueBlock");
+    exit(-1);    
+  }
+}
+
+/*
+ * Free a queue.
+ */
+void sq_freeQueue(SW_Queue queue)
+{
+  sq_freeQueueBlock(queue, 1);
+}
+
diff --git a/liberty/lib/SLAMP/SLAMPcustom/sw_queue_astream.h b/liberty/lib/SLAMP/SLAMPcustom/sw_queue_astream.h
new file mode 100644
index 00000000..8efbde38
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPcustom/sw_queue_astream.h
@@ -0,0 +1,255 @@
+/** ***********************************************/
+/** *** SW Queue with Supporting Variable Size ****/
+/** ***********************************************/
+#ifndef SW_QUEUE_H
+#define SW_QUEUE_H
+
+#include <cstdint>
+#include <iostream>
+#define DUALCORE
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <xmmintrin.h>
+#include <smmintrin.h>
+#include <unistd.h>
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+
+#include "inline.h"
+#include "bitcast.h"
+#ifndef CACHELINE_SIZE
+#define CACHELINE_SIZE 64
+/*#define CACHELINE_SIZE 64 */
+/* Cache line size of glacier, as reported by lmbench. Other tests,
+ * namely the smtx ones, vindicate this. */
+#endif /* CACHELINE_SIZE */
+
+#define QTYPE uint32_t
+#ifndef QSIZE
+#define QSIZE_BYTES (1 << 27) // 1 << 0 - 1 byte; 1 << 10 1KB; 1 << 20 1MB; 1 << 24 16MB; 1 << 26 64MB; 1 << 28 256MB; 1 << 30 1GB
+#define QSIZE (QSIZE_BYTES / sizeof(QTYPE))
+// #define QSIZE (1 << 23)
+#endif /* QSIZE */
+
+#ifndef QPREFETCH
+#define QPREFETCH (1 << 7)
+#endif /* QPREFETCH */
+
+#define PAD(suffix, size) char padding ## suffix [CACHELINE_SIZE - (size)]
+
+struct UnderlyingQueue {
+  volatile bool ready_to_read;
+  PAD(1, sizeof(bool));
+  volatile bool ready_to_write;
+  PAD(2, sizeof(bool));
+  uint64_t size;
+  PAD(3, sizeof(uint64_t));
+  uint32_t *data;
+  
+  void init(uint32_t *data){
+    this->ready_to_read = false;
+    this->ready_to_write = true;
+    this->size = 0;
+    this->data = data;
+  }
+};
+
+using Queue = UnderlyingQueue;
+using Queue_p = Queue *;
+
+struct DoubleQueue {
+  Queue_p qA, qB, qNow, qOther;
+  uint64_t index = 0;
+  uint64_t size = 0;
+  uint32_t *data;
+
+  std::mutex &m;
+  std::condition_variable &cv;
+  const unsigned ALL_THREADS;
+  unsigned &running_threads;
+  // uint32_t packet[4];
+  __m128i packet;
+
+  DoubleQueue(Queue_p dqA, Queue_p dqB, bool isConsumer, unsigned &threads, 
+      std::mutex &m, std::condition_variable &cv)
+      : qA(dqA), qB(dqB), m(m), cv(cv), running_threads(threads), ALL_THREADS(threads) {
+    this->qA = dqA;
+    this->qB = dqB;
+
+    // consumer
+    if (isConsumer) {
+      this->qNow = dqB;
+      this->qOther = dqA;
+    }
+    // producer
+    else {
+      this->qNow = dqA;
+      this->qOther = dqB;
+    }
+
+    this->data = qNow->data;
+  }
+
+  void swap(){
+    if(qNow == qA){
+      qNow = qB;
+      qOther = qA;
+    }else{
+      qNow = qA;
+      qOther = qB;
+    }
+    data = qNow->data;
+  }
+
+  void check() {
+    if (index == size) {
+      // only the last thread one does this
+      auto lock = std::unique_lock<std::mutex>(m);
+      // lock is locked
+      if (running_threads == 1) {
+        qNow->ready_to_read = false;
+        qNow->ready_to_write = true;
+        // std::cerr << "Thread " << std::this_thread::get_id() << " is waiting for queue" << std::endl;
+        while (!qOther->ready_to_read) {
+          // spin
+          usleep(10);
+        }
+        qOther->ready_to_write = false;
+        // std::cerr << "Thread " << std::this_thread::get_id() << " ready for queue" << std::endl;
+        running_threads = ALL_THREADS;
+        lock.unlock();
+        // allow all other threads to continue
+        cv.notify_all();
+        // std::cerr << "Thread " << std::this_thread::get_id() << " is ready to go" << std::endl;
+      }
+      else {
+        // lock is locked
+        running_threads--;
+        // std::cerr << "Thread " << std::this_thread::get_id() << " is waiting, threads: " << running_threads << std::endl;
+
+        // wait fo the last thread to finish
+        cv.wait(lock); // unlocks
+        // std::cerr << "Thread " << std::this_thread::get_id() << " is unlocked" << std::endl;
+        // lock reaquires
+        lock.unlock();
+        // std::cerr << "Thread " << std::this_thread::get_id() << " is ready to go" << std::endl;
+      }
+      swap();
+      index = 0;
+      size = qNow->size;
+      // // make sure all pending writes are visible
+      // _mm_mfence();
+    }
+  }
+
+  // consume a 128 bit packet and return the opcode
+  uint32_t consumePacket() {
+    // load four 32 bit integers into uint32_t[4]
+    // packet[0] = data[index++];
+    // packet[1] = data[index++];
+    // packet[2] = data[index++];
+    // packet[3] = data[index++];
+
+    // for (int i = 0; i < 16; i++) {
+    //   std::cout << data[index + i] << " ";
+    //   if (i % 4 == 3) {
+    //     std::cout << std::endl;
+    //   }
+    // }
+
+    packet = _mm_load_si128((__m128i *) &data[index]);
+    // packet = _mm_stream_load_si128((__m128i *) &data[index]);
+    index += 4;
+    uint32_t v = _mm_extract_epi32(packet, 0);
+    // get the least significant 8 bits
+    return v & 0xFF;
+    
+    // return packet[0];
+  }
+
+  void unpack_32(uint32_t &a) {
+    a = _mm_extract_epi32(packet, 1);
+  }
+
+  void unpack_64(uint64_t &c) {
+    c = _mm_extract_epi64(packet, 1);
+  }
+
+  void unpack_24_32_64(uint32_t &a, uint32_t &b, uint64_t &c) {
+    uint32_t tmp = _mm_extract_epi32(packet, 0);
+    a = tmp >> 8;
+    b = _mm_extract_epi32(packet, 1);
+    c = _mm_extract_epi64(packet, 1);
+  }
+
+  void unpack_32_32(uint32_t &a, uint32_t &b) {
+    // a = packet[1];
+    // b = packet[2];
+    a = _mm_extract_epi32(packet, 1);
+    b = _mm_extract_epi32(packet, 2);
+  }
+
+  void unpack_32_64(uint32_t &a, uint64_t &c) {
+    // std::cout << packet[0] << " " << packet[1] << " " << packet[2] << " " << packet[3] << std::endl;
+    // a = packet[1];
+    // c = ((uint64_t) packet[3] << 32) | packet[2];
+    // c = ((uint64_t) packet[2] << 32) | packet[3];
+    // c = *(uint64_t*) &packet[2];
+    a = _mm_extract_epi32(packet, 1);
+    c = _mm_extract_epi64(packet, 1);
+  }
+
+  // uint32_t consume32() {
+  //   uint32_t ret = data[index];
+  //   index++;
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_NTA);
+  //   return ret;
+  // }
+
+  // uint64_t consume64() {
+  //   uint64_t ret = *(uint64_t *) &data[index];
+  //   index += 2;
+  //   return ret;
+  // }
+
+  // void consume_64_64(uint64_t &x, uint64_t &y) {
+  //   uint64_t *ptr = (uint64_t *) &data[index];
+  //   x = ptr[0];
+  //   y = ptr[1];
+  //   index += 4;
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_T0);
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_NTA);
+  // }
+
+  // void consume_32_32(uint32_t &x, uint32_t &y) {
+  //   uint32_t *ptr = &data[index];
+  //   x = ptr[0];
+  //   y = ptr[1];
+  //   index += 2;
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_T0);
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_NTA);
+  // }
+
+  // void consume_32_64(uint32_t &x, uint64_t &y) {
+  //   uint32_t *ptr = &data[index];
+  //   x = ptr[0];
+  //   y = *(uint64_t *) &ptr[1];
+  //   index += 3;
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_T0);
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_NTA);
+  // }
+
+  // void consume_32_32_64(uint32_t &x, uint32_t &y, uint64_t &z) {
+  //   uint32_t *ptr = &data[index];
+  //   x = ptr[0];
+  //   y = ptr[1];
+  //   z = *(uint64_t *) &ptr[2];
+  //   index += 4;
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_T0);
+  //   // _mm_prefetch(&dq_data[dq_index] + QPREFETCH, _MM_HINT_NTA);
+  // }
+};
+#endif /* SW_QUEUE_H */
diff --git a/liberty/lib/SLAMP/SLAMPlib/hooks/context.h b/liberty/lib/SLAMP/SLAMPlib/hooks/context.h
new file mode 100644
index 00000000..bb5ec242
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPlib/hooks/context.h
@@ -0,0 +1,233 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_CONTEXT_H
+#define SLAMPLIB_HOOKS_SLAMP_CONTEXT_H
+
+/* The context management
+ * ======================
+ * The definition of a context is very specific to the client. For SpecPriv,
+ * the dynamic context is defined as the function and loop stack.
+ *
+ * For loop-aware memory dependnece profiling, the context is the loop and the
+ * invocation and iteration count.
+ *
+ * The context information usually needs to be stored in the shadow memory.
+ * 
+ * The context management is responsible for keeping track the current context
+ * and creating a fixed length representation of any context.
+ *
+ */
+
+#include <iostream>
+#include <stack>
+#include <utility>
+#include <map>
+#include "llvm/IR/Instruction.h"
+#include "scaf/Utilities/Metadata.h"
+
+namespace SLAMPLib {
+
+using ContextHash = size_t;
+
+/// The context is stack of the ContextId
+template <typename ContextId> struct Context {
+  ContextId id;
+  Context *parent;
+
+  Context(ContextId id, Context *parent) : id(std::move(id)), parent(parent) {}
+
+  /// Add a new context to the stack
+  Context *chain(ContextId id) { return new Context(id, this); }
+
+  static Context* getTopContext() {
+    return new Context(ContextId::getTopContextId(), nullptr);
+  }
+
+  ContextHash hash() {
+    ContextHash h = id.hash();
+    if (parent)
+      h ^= parent->hash();
+    return h;
+  }
+
+  /// Remove the top context from the stack
+  Context *pop() {
+    auto parent = this->parent;
+    // FIXME: is this ok to use?
+    delete this;
+    return parent;
+  }
+  using FlattenContext = std::vector<ContextId>;
+  using ContextIdType = ContextId;
+
+  /// make the context into a vector of only the context id
+  FlattenContext flatten() {
+    std::vector<ContextId> result;
+    Context *cur = this;
+    while (cur) {
+      result.push_back(cur->id);
+      cur = cur->parent;
+    }
+    return result;
+  };
+
+  /// print context
+  void print(std::ostream &os) {
+    os << "Context:\n";
+    Context *cur = this;
+    while (cur) {
+      cur->id.print(os);
+      cur = cur->parent;
+    }
+  }
+};
+
+/// Note that we do no need to keep track of
+/// all the objects that are alive
+template <class Context>
+struct ContextManager {
+  Context *activeContext;
+
+  ContextManager() {
+    activeContext = Context::getTopContext();
+  }
+
+  std::unordered_map <ContextHash, typename Context::FlattenContext> contextMap;
+
+  ContextHash activeId() {
+    if (activeContext)
+      return activeContext->hash();
+    else
+      return 0;
+  }
+
+  void updateContext(typename Context::ContextIdType contextId) {
+    assert(activeContext && "active context is null");
+    /// maybe this is not a great idea, expose the semantics of the context to the manager
+    activeContext = activeContext->chain(contextId);
+    // addContext(activeContext->hash(), *activeContext);
+  }
+
+  void popContext(typename Context::ContextIdType contextId) {
+    assert(activeContext && "active context is null");
+
+    if (activeContext->id == contextId) {
+      activeContext = activeContext->pop();
+    } else {
+      // The context is not matching, could be due to the longjmp/setjmp etc or
+      // exception handling in C++
+      std::cerr << "Context mismatch! Current context: ";
+      auto tmp = activeContext;
+      while (tmp->parent) {
+        std::cerr << "(" << tmp->id.type << "," << tmp->id.metaId << ")->";
+        tmp = tmp->parent;
+      }
+      std::cerr << "(" << tmp->id.type << "," << tmp->id.metaId << ")->";
+      std::cerr << "Exiting context: (" << contextId.type << ","
+                << contextId.metaId << ")" << std::endl;
+
+      // Let's try to find the correct context
+      bool foundInStack = false;
+      while (activeContext->parent) {
+        activeContext = activeContext->pop();
+        if (activeContext->id == contextId) {
+          foundInStack = true;
+          break;
+        }
+      }
+
+      assert(foundInStack && "Could not find the exiting context in the stack");
+    }
+  }
+
+  void addContext(ContextHash hash, Context &context) {
+
+    // if exist one but not the same, then we have a problem
+    if (contextMap.count(hash) && contextMap[hash] != context.flatten()) {
+      // FIXME: need to turn this back on
+      // assert(false && "Context hash collision");
+    }
+
+    // insert the context
+    contextMap[hash] = context.flatten();
+  }
+};
+
+namespace SpecPrivLib {
+enum SpecPrivContextType {
+  TopContext = 0,
+  FunctionContext,
+  LoopContext,
+};
+
+
+struct ContextId {
+  SpecPrivContextType type;
+  int32_t metaId;
+  ContextId(SpecPrivContextType type, int32_t id) : type(type), metaId(id) {}
+  ContextId(std::pair<SpecPrivContextType, int32_t> p)
+      : type(p.first), metaId(p.second) {}
+  static ContextId getTopContextId() { return {TopContext, 0}; }
+  // id left shift 2 bits and or with type
+  ContextHash hash() {
+    return (static_cast<ContextHash>(metaId) << 2) | static_cast<ContextHash>(type);
+  }
+
+  bool operator==(const ContextId &other) const {
+    return type == other.type && metaId == other.metaId;
+  }
+
+  bool operator<(const ContextId &other) const {
+    return type < other.type || (type == other.type && metaId < other.metaId);
+  }
+
+  void print(std::ostream &os) {
+    os << "ContextId: " << type << " " << metaId << "\n";
+  }
+};
+using SpecPrivContext = Context<ContextId>;
+
+struct SpecPrivContextManager : public ContextManager<SpecPrivContext> {
+
+  std::map<std::vector<ContextId>, ContextHash> contextIdHashMap;
+  size_t contextIdHashCounter = 1;
+  
+  SpecPrivContext *cachedActiveContext;
+  ContextHash cachedContextHash;
+
+  ContextHash encodeContext(SpecPrivContext context) {
+    std::vector<ContextId> flattenContext = context.flatten();
+    if (contextIdHashMap.count(flattenContext)) {
+      return contextIdHashMap[flattenContext];
+    } else {
+      contextIdHashMap[flattenContext] = contextIdHashCounter;
+      contextMap[contextIdHashCounter] = flattenContext;
+
+      return contextIdHashCounter++;
+    }
+  }
+
+  ContextHash encodeActiveContext() {
+    // std::cerr << "encodeActiveContext: ";
+    // activeContext->print(std::cerr);
+    if (activeContext == cachedActiveContext) {
+      return cachedContextHash;
+    } else {
+      cachedActiveContext = activeContext;
+      cachedContextHash = encodeContext(*activeContext);
+      return cachedContextHash;
+    }
+  }
+
+  std::vector<ContextId> decodeContext(ContextHash hash) {
+    if (contextMap.count(hash)) {
+      return contextMap[hash];
+    } else {
+      assert(false && "Could not find the context");
+      return {};
+    }
+  }
+
+};
+}; // namespace SpecPrivLib
+
+} // namespace SLAMPLib
+#endif // SLAMPLIB_HOOKS_SLAMP_CONTEXT_H
diff --git a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.cpp b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.cpp
index 285bb430..700cb0b3 100644
--- a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.cpp
+++ b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.cpp
@@ -20,6 +20,7 @@
 #include "slamp_debug.h"
 
 #include "slamp_timer.h"
+#include "context.h"
 
 
 #include <set>
@@ -30,6 +31,8 @@
 #define UNW_LOCAL_ONLY
 #include <libunwind.h>
 
+using namespace SLAMPLib;
+
 #define TURN_OFF_CUSTOM_MALLOC do {\
   __malloc_hook = old_malloc_hook; \
   __free_hook = old_free_hook; \
@@ -48,6 +51,9 @@
 #define HEAP_BOUND_HIGHER (0xFFFFFFFFFFFFL-BOUND_LOWER+1)
 // 8MB max stack size for a typical host machine `ulimit -s`
 #define SIZE_8M  0x800000
+
+#define  FORMAT_INST_ARG(fcnId, argId) (fcnId << 5 | (0x1f & (argId  << 4) | 0x1))
+#define FORMAT_INST_INST(instId) (instId << 1 | 0x0)
 // #define LOCALWRITE(addr) if (true)
 
 // debugging tools
@@ -108,6 +114,10 @@ extern size_t LOCALWRITE_PATTERN;
 
 #define LOCALWRITE(addr)  ((!LOCALWRITE_MODULE || ((size_t)addr & LOCALWRITE_MASK) == LOCALWRITE_PATTERN))
 
+static void *(*old_malloc_hook)(size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+
 uint64_t __slamp_iteration = 0;
 uint64_t __slamp_invocation = 0;
 
@@ -115,6 +125,9 @@ uint64_t __slamp_load_count = 0;
 uint64_t __slamp_store_count = 0;
 uint64_t __slamp_malloc_count = 0;
 uint64_t __slamp_free_count = 0;
+SpecPrivLib::SpecPrivContextManager *contextManager;
+std::unordered_set<unsigned long> *shortLivedObjects, *longLivedObjects;
+std::unordered_set<ContextHash> *targetLoopContexts;
 
 // Type of the access callback function
 // instr, bare_instr, address, value, size
@@ -131,6 +144,7 @@ void slamp_global_callback(const char* name, uint64_t addr, uint64_t size) {}
 
 // TODO: activate shadow memory (SLAMP_malloc)
 void SLAMP_callback_stack_alloca(uint64_t array_size, uint64_t type_size, uint32_t instr, uint64_t addr) {
+  TURN_OFF_CUSTOM_MALLOC;
   uint64_t size = array_size*type_size;
 
   if (DEPENDENCE_MODULE || POINTS_TO_MODULE) {
@@ -138,16 +152,45 @@ void SLAMP_callback_stack_alloca(uint64_t array_size, uint64_t type_size, uint32
     void* shadow = (void*)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
     if (shadow && POINTS_TO_MODULE) {
       TS *s = (TS *)shadow;
-      TS ts = CREATE_TS(instr, __slamp_iteration, __slamp_invocation);
+      auto hash = contextManager->encodeActiveContext();
+      TS ts = CREATE_TS(instr, hash, __slamp_invocation);
       for (auto i = 0; i < size; i++)
         s[i] = ts;
     }
   }
-    return;
+
+  TURN_ON_CUSTOM_MALLOC;
+  return;
 }
 
 
-void SLAMP_callback_stack_free(void) {}
+void SLAMP_callback_stack_free(void) {
+  // do not need to free memory or shadow memory, it gets reused implicitly
+
+  // // Need to record short-lived objects
+  // // need to check if the object is short-lived
+  // if (POINTS_TO_MODULE) {
+  //   // if we are still in the loop and the iteration is the same, mark it as local
+  //   // otherwise mark it as not local
+  //   TS* s = (TS*)GET_SHADOW(ptr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+  //   auto instr = GET_INSTR(s[0]);
+  //   auto iteration  = GET_ITER(s[0]);
+  //   auto invocation = GET_INVOC(s[0]);
+
+  //   // if invokedepth is 0, it means we are not in a loop
+  //   if (iteration == (0xffffffffff & __slamp_iteration) 
+  //       && invocation == (0xf & __slamp_invocation)
+  //       && invokedepth > 0) {
+  //     // is short-lived, put in the set
+  //     shortLivedObjects.insert(instr);
+  //   }
+  //   else {
+  //     // is not short-lived
+  //     longLivedObjects.insert(instr);
+  //   }
+
+  // }
+}
 
 // Callback function pointers
 std::list<AccessCallbackTy> *access_callbacks;
@@ -308,7 +351,7 @@ void slamp_access_callback_constant_value(bool isLoad, uint32_t instr, uint32_t
       }
     }
   } else {
-    auto cp = new Constant(1, 1, size, addr, value);
+    auto cp = new Constant(true, true, size, addr, value);
     constmap_value->insert(std::make_pair(key, cp));
   }
 }
@@ -378,7 +421,7 @@ void slamp_access_callback_linear_address(bool isLoad, uint32_t instr, uint32_t
   }
 }
 
-static uint32_t          context = 0;
+static uint32_t          StaticInstIdOfLOI = 0;
 static uint32_t          ext_context = 0;
 slamp::MemoryMap* smmap = nullptr;
 
@@ -405,10 +448,19 @@ void updateInstruction(uint32_t instr, uint64_t addr) {
 using SlampAllocationUnit = TS;
 
 // map from load/store instruction to the allocation unit
-std::unordered_map<uint32_t, std::unordered_set<SlampAllocationUnit>> *pointsToMap;
+std::unordered_map<uint64_t, std::unordered_set<SlampAllocationUnit>> *pointsToMap;
+// std::unordered_map<uint32_t, std::unordered_set<SlampAllocationUnit>> *pointsToMap;
 
 template <unsigned size>
 void SLAMP_points_to_module_use(uint32_t instr, uint64_t addr) {
+  TURN_OFF_CUSTOM_MALLOC;
+
+  auto contextHash = contextManager->encodeActiveContext();
+  uint64_t instrAndHash = ((uint64_t)instr << 32) | contextHash;
+  if (addr == 0) {
+    (*pointsToMap)[instrAndHash].insert(0);
+    return;
+  }
   TS* s = (TS*)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
   TS tss[8]; // HACK: avoid using malloc
   for (auto i = 0; i < size; i++) {
@@ -422,14 +474,27 @@ void SLAMP_points_to_module_use(uint32_t instr, uint64_t addr) {
     }
 
     if (cond && tss[i] != 0) {
+      // mask off the iteration count
+      TS ts = tss[i];
+      ts = ts & 0xffffffffffffff00;
+      // ts = ts & 0xfffffffffffffff0;
+      // ts = ts & 0xfffff0000000000f;
       //create set of objects for each load/store
-      (*pointsToMap)[instr].insert(tss[i]);
+      (*pointsToMap)[instrAndHash].insert(ts);
     }
   }
+  TURN_ON_CUSTOM_MALLOC;
 }
 
 void SLAMP_points_to_module_use(uint32_t instr, uint64_t addr, unsigned size) {
+  TURN_OFF_CUSTOM_MALLOC;
 
+  auto contextHash = contextManager->encodeActiveContext();
+  uint64_t instrAndHash = ((uint64_t)instr << 32) | contextHash;
+  if (addr == 0) {
+      (*pointsToMap)[instrAndHash].insert(0);
+      return;
+  }
   std::unordered_set<TS> m;
   TS *s = (TS *)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
 
@@ -440,11 +505,17 @@ void SLAMP_points_to_module_use(uint32_t instr, uint64_t addr, unsigned size) {
     TS ts;
     ts = s[i];
 
+    // mask off the iteration count
+      // ts = ts & 0xfffff00000000000;
+      ts = ts & 0xfffffffffffffe00;
+    // ts = ts & 0xfffffffffffffff0;
+    // ts = ts & 0xfffff0000000000f;
     if (m.count(ts) == 0) {
-      (*pointsToMap)[instr].insert(ts);
+      (*pointsToMap)[instrAndHash].insert(ts);
       m.insert(ts);
     }
   }
+  TURN_ON_CUSTOM_MALLOC;
 }
 
 // -1->inconclusive
@@ -679,10 +750,6 @@ static void __slamp_sigsegv_handler(int sig, siginfo_t *siginfo, void *dummy)
 }
 
 
-static void *(*old_malloc_hook)(size_t, const void *);
-static void (*old_free_hook)(void *, const void *);
-static void *(*old_memalign_hook)(size_t, size_t, const void *);
-
 static void* SLAMP_malloc_hook(size_t size, const void * /*caller*/) {
   auto ptr = SLAMP_malloc(size, ext_context, 16);
 
@@ -704,6 +771,13 @@ static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *call
 
 void SLAMP_init(uint32_t fn_id, uint32_t loop_id)
 {
+
+  if (POINTS_TO_MODULE) {
+    contextManager = new SpecPrivLib::SpecPrivContextManager();
+    shortLivedObjects = new std::unordered_set<uint64_t>();
+    longLivedObjects = new std::unordered_set<uint64_t>();
+    targetLoopContexts = new std::unordered_set<uint64_t>();
+  }
   // auto heapStart = sbrk(0);
   // fprintf(stderr, "heap start: %lx\n", (unsigned long)heapStart);
 
@@ -756,7 +830,7 @@ void SLAMP_init(uint32_t fn_id, uint32_t loop_id)
   }
 
   // initialize pointsToMap
-  pointsToMap = new std::unordered_map<uint32_t, std::unordered_set<SlampAllocationUnit>>();
+  pointsToMap = new std::unordered_map<uint64_t, std::unordered_set<SlampAllocationUnit>>();
 
 // #ifndef ITO_ENABLE
 // // FIXME: LOCALWRITE stuff should also be converted to constant if possible
@@ -817,6 +891,14 @@ void SLAMP_init(uint32_t fn_id, uint32_t loop_id)
   smmap->allocate((void*)&stdout, sizeof(stdout));
   smmap->allocate((void*)&stderr, sizeof(stderr));
   smmap->allocate((void*)&sys_nerr, sizeof(sys_nerr));
+  if (POINTS_TO_MODULE) {
+    auto size = sizeof(*stdout);
+    auto shadow = (TS*)smmap->allocate((void*)stdout, size);
+    for (auto i = 0; i < size; i+= size) {
+      TS ts = ~(TS)0;
+      shadow[i] = ts;
+    }
+  }
 
   {
     const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
@@ -876,10 +958,108 @@ void SLAMP_fini(const char* filename)
         }
         ofs << "\n";
       }
+      ofs << "Short-lived object:\n";
+      ofs << shortLivedObjects->size() << " " << longLivedObjects->size() << "\n";
+      for (auto &obj: *shortLivedObjects) {
+        // if short-lived
+        ofs << obj << "\n";
+      }
+
+      for (auto &obj: *longLivedObjects) {
+        // if long-lived
+        ofs << obj << "\n";
+      }
+
       ofs.close();
     }
   }
 
+  // Dump compatible one as SpecPriv output
+  std::ofstream specprivfs("specpriv-profile.out");
+  specprivfs << "BEGIN SPEC PRIV PROFILE\n";
+  specprivfs << "COMPLETE ALLOCATION INFO ; \n";
+
+  auto printContext = [&specprivfs](const std::vector<SpecPrivLib::ContextId> &ctx) {
+    for (auto &c : ctx) {
+      specprivfs << "(" << c.type << "," << c.metaId << ")";
+    }
+  };
+
+  if (POINTS_TO_MODULE) {
+    // print all loop contexts
+    specprivfs << "LOOP CONTEXTS: " << targetLoopContexts->size() << "\n";
+    for (auto contextHash : *targetLoopContexts) {
+      auto context = contextManager->decodeContext(contextHash);
+      printContext(context);
+      specprivfs << "\n";
+    }
+
+    // local objects
+    for (auto &obj: *shortLivedObjects) {
+      // LOCAL OBJECT AU HEAP main if.else.i call.i4.i FROM  CONTEXT { LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  IS LOCAL TO  CONTEXT { LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  COUNT 300 ;
+      auto instr = GET_INSTR(obj);
+      auto hash = GET_HASH(obj);
+      auto context = contextManager->decodeContext(hash);
+      specprivfs << "LOCAL OBJECT " << instr << " at context ";
+      printContext(context);
+      specprivfs << ";\n";
+
+    }
+
+  }
+
+  // predict int and predict ptr (only NULL)
+  // Note that the int prediction is in place, however SpecPriv rematerializes the load to the preheader of the loop
+
+  // PRED INT main enqueue.exit23.i $0 AT  CONTEXT { LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  AS PREDICTABLE 301 SAMPLES OVER 1 VALUES {  ( INT 0 COUNT 301 )  } ;
+  // PRED PTR main if.then29.i $17 AT  CONTEXT { LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  AS PREDICTABLE 301 SAMPLES OVER 1 VALUES {  ( OFFSET 0 BASE AU NULL  COUNT 301 )  } ;
+
+  if (CONSTANT_VALUE_MODULE) {
+    for (auto &[key, cp] : *constmap_value) {
+      if (cp->valid) {
+        // instr and value
+        auto instr = key.first;
+        auto value = cp->value;
+        // later, we need to parse the instruction to see if it's a pointer or a regular integer
+        specprivfs << "PRED VAL " << instr << " " << value << " ; \n";
+      }
+    }
+  }
+  // predict OBJ
+  //  PRED OBJ main if.else.i $0 AT  CONTEXT { LOOP main for.cond15 1 WITHIN FUNCTION main WITHIN TOP }  AS PREDICTABLE 300 SAMPLES OVER 1 VALUES {  ( OFFSET 0 BASE AU HEAP allocate_matrices for.end call7 FROM  CONTEXT { FUNCTION allocate_matrices WITHIN FUNCTION main WITHIN TOP }  COUNT 300 )  } ;
+  if (POINTS_TO_MODULE) {
+    for (auto &it : *pointsToMap) {
+      auto instr = it.first >> 32;
+      auto instrHash = it.first & 0xFFFFFFFF;
+      std::vector<SpecPrivLib::ContextId> instrContext = contextManager->decodeContext(instrHash);
+      specprivfs << "PRED OBJ " << instr << " at ";
+      printContext(instrContext);
+      specprivfs << ": " << it.second.size() << "\n"; // instruction ID
+      for (auto &it2 : it.second) { // the set of allocation units
+        auto hash = GET_HASH(it2);
+
+        specprivfs << "AU "; 
+        if (it2 == 0xffffffffffffff00) {
+          specprivfs << " UNMANAGED";
+        }
+        else if (it2 == 0) {
+          specprivfs << " NULL";
+        } else {
+          std::vector<SpecPrivLib::ContextId> context = contextManager->decodeContext(hash);
+
+          specprivfs <<GET_INSTR(it2);
+          specprivfs << " FROM CONTEXT " ;
+          printContext(context);
+        }
+        specprivfs << ";\n";
+      }
+    }
+  }
+
+
+  specprivfs << " END SPEC PRIV PROFILE\n";
+
+
   if (DEPENDENCE_MODULE) {
     slamp::fini_logger(filename);
     // delete smmap;
@@ -964,11 +1144,69 @@ void SLAMP_main_entry(uint32_t argc, char** argv, char** env)
   TURN_ON_CUSTOM_MALLOC;
 }
 
+/// Keep track of the context of the function
+void SLAMP_enter_fcn(uint32_t fcnId) {
+  if (POINTS_TO_MODULE) {
+    TURN_OFF_CUSTOM_MALLOC;
+
+    // std::cerr << "entering function " << fcnId << std::endl;
+    auto contextId = SpecPrivLib::ContextId(SpecPrivLib::FunctionContext, fcnId);
+
+    // update the current context
+    contextManager->updateContext(contextId);
+    TURN_ON_CUSTOM_MALLOC;
+  }
+}
+
+void SLAMP_enter_loop(uint32_t bbId) {
+  if (POINTS_TO_MODULE) {
+    TURN_OFF_CUSTOM_MALLOC;
+
+    // std::cerr << "entering function " << fcnId << std::endl;
+    auto contextId = SpecPrivLib::ContextId(SpecPrivLib::LoopContext, bbId);
+
+    // update the current context
+    contextManager->updateContext(contextId);
+    TURN_ON_CUSTOM_MALLOC;
+  }
+}
+
+void SLAMP_exit_loop(uint32_t bbId) {
+  if (POINTS_TO_MODULE) {
+    TURN_OFF_CUSTOM_MALLOC;
+    auto contextId = SpecPrivLib::ContextId(SpecPrivLib::LoopContext, bbId);
+
+    // std::cerr << "exiting function " << fcnId << std::endl;
+    // update the current context
+    contextManager->popContext(contextId);
+    TURN_ON_CUSTOM_MALLOC;
+  }
+}
+
+/// Keep track of the context of the function
+void SLAMP_exit_fcn(uint32_t fcnId) {
+  if (POINTS_TO_MODULE) {
+    TURN_OFF_CUSTOM_MALLOC;
+    auto contextId = SpecPrivLib::ContextId(SpecPrivLib::FunctionContext, fcnId);
+
+    // std::cerr << "exiting function " << fcnId << std::endl;
+    // update the current context
+    contextManager->popContext(contextId);
+    TURN_ON_CUSTOM_MALLOC;
+  }
+}
+
+void SLAMP_loop_iter_ctx(uint32_t id) {}
+
 /// update the invocation count
 void SLAMP_loop_invocation() {
+  TURN_OFF_CUSTOM_MALLOC;
   // fprintf(stderr, "SLAMP_loop_invocation, depth: %u\n", invokedepth);
   invokedepth++;
 
+  if (POINTS_TO_MODULE)
+    targetLoopContexts->insert(contextManager->encodeActiveContext());
+
   if (invokedepth > 1)
     return;
 
@@ -983,6 +1221,8 @@ void SLAMP_loop_invocation() {
   if (__slamp_begin_trace)
     std::cout << "[invoke] " << (__slamp_invocation) << "\n" << std::flush;
 #endif
+  
+  TURN_ON_CUSTOM_MALLOC;
 }
 
 void SLAMP_loop_iteration()
@@ -1005,6 +1245,37 @@ void SLAMP_loop_exit() {
   invokedepth--;
 }
 
+// FIXME: a temporary patch for out of handling program original heap
+bool SLAMP_isBadAlloc(uint64_t addr) ATTRIBUTE(always_inline) {
+  const uint64_t  lower = 0x100000000L;
+  const uint64_t higher =  0x010000000000L;
+  const uint64_t heapStart = smmap->heapStart;
+
+  if (addr < lower && addr > heapStart) {
+    return true;
+  }
+
+  return false;
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t fcnId, uint32_t argId, void *ptr){
+  if (invokedepth == 0)
+    return;
+  if (SLAMP_isBadAlloc((uint64_t)ptr)) {
+    return;
+  }
+  SLAMP_points_to_module_use<1>(FORMAT_INST_ARG(fcnId, argId), (uint64_t)ptr);
+}
+
+void SLAMP_report_base_pointer_inst(uint32_t instId, void *ptr){
+  if (invokedepth == 0)
+    return;
+  if (SLAMP_isBadAlloc((uint64_t)ptr)) {
+    return;
+  }
+  SLAMP_points_to_module_use<1>(FORMAT_INST_INST(instId), (uint64_t)ptr);
+}
+
 /// set the context of the call inside a loop
 void SLAMP_ext_push(const uint32_t instr) ATTRIBUTE(always_inline) {
   assert(ext_context == 0);
@@ -1028,8 +1299,8 @@ void SLAMP_push(const uint32_t instr) {
               << std::flush;
 #endif
 
-  assert(context == 0);
-  context = instr;
+  assert(StaticInstIdOfLOI == 0);
+  StaticInstIdOfLOI = instr;
 }
 
 /// unset the context of the call inside a loop
@@ -1044,20 +1315,7 @@ void SLAMP_pop() {
               << std::flush;
 #endif
 
-  context = 0;
-}
-
-// FIXME: a temporary patch for out of handling program original heap
-bool SLAMP_isBadAlloc(uint64_t addr) ATTRIBUTE(always_inline) {
-  const uint64_t  lower = 0x100000000L;
-  const uint64_t higher =  0x010000000000L;
-  const uint64_t heapStart = smmap->heapStart;
-
-  if (addr < lower && addr > heapStart) {
-    return true;
-  }
-
-  return false;
+  StaticInstIdOfLOI = 0;
 }
 
 template <unsigned size>
@@ -1144,7 +1402,7 @@ void SLAMP_dependence_module_load_log(const uint32_t instr, const uint32_t bare_
 template <unsigned size>
 void SLAMP_load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
   if (invokedepth > 1)
-    instr = context;
+    instr = StaticInstIdOfLOI;
   if (SLAMP_isBadAlloc(addr))
     return;
 
@@ -1172,9 +1430,9 @@ void SLAMP_load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr,
       SLAMP_dependence_module_load_log<size>(instr, bare_instr, value, addr);
     }
 
-    if (POINTS_TO_MODULE) {
-      SLAMP_points_to_module_use<size>(instr, addr);
-    }
+    // if (POINTS_TO_MODULE) {
+    //   SLAMP_points_to_module_use<size>(instr, addr);
+    // }
 #ifndef ITO_ENABLE
     TURN_ON_CUSTOM_MALLOC;
 #endif
@@ -1208,7 +1466,7 @@ void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr,
   if (SLAMP_isBadAlloc(addr))
     return;
   if (invokedepth > 1)
-    instr = context;
+    instr = StaticInstIdOfLOI;
 
   if (TRACE_MODULE) {
     __slamp_load_count++;
@@ -1232,10 +1490,10 @@ void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr,
       SLAMP_dependence_module_load_log(instr, bare_instr, 0, addr, n);
     }
 
-    if (POINTS_TO_MODULE) {
-      // only need to check once
-      SLAMP_points_to_module_use(instr, addr, n);
-    }
+    // if (POINTS_TO_MODULE) {
+    //   // only need to check once
+    //   SLAMP_points_to_module_use(instr, addr, n);
+    // }
 
     TURN_ON_CUSTOM_MALLOC;
   }
@@ -1250,8 +1508,8 @@ void SLAMP_load_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t val
               << addr << std::dec << "\n"
               << std::flush;
 #endif
-  if (context)
-    SLAMP_load<size>(context, addr, bare_instr, value);
+  if (StaticInstIdOfLOI)
+    SLAMP_load<size>(StaticInstIdOfLOI, addr, bare_instr, value);
 }
 
 
@@ -1284,8 +1542,8 @@ void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) {
               << std::flush;
 #endif
 
-  if (context)
-    SLAMP_loadn(context, addr, bare_instr, n);
+  if (StaticInstIdOfLOI)
+    SLAMP_loadn(StaticInstIdOfLOI, addr, bare_instr, n);
 }
 
 template <unsigned size>
@@ -1331,7 +1589,7 @@ void SLAMP_store(uint32_t instr, uint32_t bare_instr, const uint64_t addr) ATTRI
 
   // TODO: do we care about recursive calls?
   if (invokedepth > 1)
-    instr = context;
+    instr = StaticInstIdOfLOI;
   
   if (TRACE_MODULE) {
     __slamp_store_count++;
@@ -1368,9 +1626,9 @@ void SLAMP_store(uint32_t instr, uint32_t bare_instr, const uint64_t addr) ATTRI
       SLAMP_dependence_module_store_log<size>(instr, addr);
     }
 
-    if (POINTS_TO_MODULE) {
-      SLAMP_points_to_module_use<size>(instr, addr);
-    }
+    // if (POINTS_TO_MODULE) {
+    //   SLAMP_points_to_module_use<size>(instr, addr);
+    // }
 #ifndef ITO_ENABLE
   TURN_ON_CUSTOM_MALLOC;
 #endif
@@ -1397,7 +1655,7 @@ void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) {
   if (SLAMP_isBadAlloc(addr))
     return;
   if (invokedepth > 1)
-    instr = context;
+    instr = StaticInstIdOfLOI;
 
   if (TRACE_MODULE) {
     __slamp_store_count++;
@@ -1423,10 +1681,10 @@ void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) {
       SLAMP_dependence_module_store_log(instr, addr, n);
     }
 
-    if (POINTS_TO_MODULE) {
-      // only need to check once
-      SLAMP_points_to_module_use(instr, addr, n);
-    }
+    // if (POINTS_TO_MODULE) {
+    //   // only need to check once
+    //   SLAMP_points_to_module_use(instr, addr, n);
+    // }
     TURN_ON_CUSTOM_MALLOC;
   }
 }
@@ -1441,8 +1699,8 @@ void SLAMP_store_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(al
               << std::flush;
 #endif
 
-  if (context)
-    SLAMP_store<size>(context, bare_inst, addr);
+  if (StaticInstIdOfLOI)
+    SLAMP_store<size>(StaticInstIdOfLOI, bare_inst, addr);
 }
 
 
@@ -1471,8 +1729,8 @@ void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) {
               << std::flush;
 #endif
 
-  if (context)
-    SLAMP_storen(context, addr, n);
+  if (StaticInstIdOfLOI)
+    SLAMP_storen(StaticInstIdOfLOI, addr, n);
 }
 
 /*
@@ -1512,7 +1770,23 @@ void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment)
           // cast as timestamp
           TS *s = (TS *)shadow;
           // log all data into sigle TS
-          TS ts = CREATE_TS(instr, __slamp_iteration, __slamp_invocation);
+          // FIXME: static instruction and the dynamic context?
+          // context: static instr + function + loop
+          auto hash = contextManager->encodeActiveContext();
+          // print active context
+          // contextManager->activeContext->print(std::cerr);
+
+          // currentContext->print(std::cerr);
+          // std::cerr << "malloc hash: " << hash << "\n";
+
+          // TS ts = CREATE_TS(instr, hash, __slamp_invocation);
+          TS ts = CREATE_TS_HASH(instr, hash, __slamp_iteration, __slamp_iteration);
+          // std::cerr << "TS: " << std::hex << ts << std::dec << "\n";
+          // TS ts = CREATE_TS(instr, __slamp_iteration, __slamp_invocation);
+          if (instr == 0) {
+            std::cerr << "Ext context: " << ext_context << "\n";
+          }
+
           //8 bytes per byte TODO: can we reduce this?
           for (auto i = 0; i < size; i++)
             s[i] = ts;
@@ -1546,16 +1820,56 @@ void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment)
 
 void  SLAMP_free(void* ptr)
 {
+  if (ptr == nullptr)
+    return;
+
+  if (SLAMP_isBadAlloc((uint64_t)ptr))
+    return;
+
   TURN_OFF_CUSTOM_MALLOC;
   
   uint64_t starting_page;
   unsigned purge_cnt;
   bool purge = slamp::bound_free(ptr, starting_page, purge_cnt);
 
+  // need to check if the object is short-lived
+  if (POINTS_TO_MODULE) {
+    // if we are still in the loop and the iteration is the same, mark it as local
+    // otherwise mark it as not local
+    TS* s = (TS*)GET_SHADOW(ptr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+    auto instr = GET_INSTR(s[0]);
+    auto hash = GET_HASH(s[0]);
+    auto iteration  = GET_ITER(s[0]) & 0xF;
+    auto invocation = GET_INVOC(s[0]);
+
+    auto instrAndHash = s[0] & 0xFFFFFFFFFFFFFF00;
+    
+    if (instr == 0) {
+      std::cerr << "TS: " << s[0] << " ptr: " << ptr << "\n";
+    }
+
+    // if invokedepth is 0, it means we are not in a loop
+    if (iteration == (0xf & __slamp_iteration) 
+        && invocation == (0xf & __slamp_invocation)
+        && invokedepth > 0) {
+      // is short-lived, put in the set
+      shortLivedObjects->insert(instrAndHash);
+      for (auto &obj: *shortLivedObjects) {
+        std::cerr << "short lived object: " << obj << "\n";
+      }
+    }
+    else {
+      // is not short-lived
+      longLivedObjects->insert(instrAndHash);
+    }
+
+  }
+
   if (DEPENDENCE_MODULE || POINTS_TO_MODULE) {
     if (purge)
       smmap->deallocate_pages(starting_page, purge_cnt);
   }
 
   TURN_ON_CUSTOM_MALLOC;
+
 }
diff --git a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.h
index fb803f93..df546117 100644
--- a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.h
+++ b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_hooks.h
@@ -61,10 +61,17 @@ void SLAMP_allocated(uint64_t addr);
 void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
 void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
 
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
 void SLAMP_loop_invocation();
 void SLAMP_loop_iteration();
 void SLAMP_loop_exit();
 
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
 void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
 void SLAMP_callback_stack_free(void);
 
diff --git a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_timestamp.h b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_timestamp.h
index 419d3f9b..fc9c1428 100644
--- a/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_timestamp.h
+++ b/liberty/lib/SLAMP/SLAMPlib/hooks/slamp_timestamp.h
@@ -9,7 +9,12 @@ typedef uint64_t TS; // first 20 bits for instr and following 44 bits for iter
 #define ITERATION_SIZE 40
 #define INVOCATION_SIZE 4 // 44-40
 #define CREATE_TS(instr, iter, invoc) ( ((TS)instr << 44) | (((TS)iter & (TS)0xffffffffff) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xf))
-#define GET_INSTR(ts) ( (ts >> 44) & 0xfffff )
+#define CREATE_TS_HASH(instr, hash, iter, invoc)                               \
+  (((TS)instr << 44) |                                                         \
+   (((TS)hash & (TS)0xfffffffff) << (INVOCATION_SIZE + 4)) |                   \
+   (((TS)iter & (TS)0xf) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xf))
+#define GET_INSTR(ts) ((ts >> 44) & 0xfffff)
+#define GET_HASH(ts) ( (ts >> 8) & 0xfffffffff)
 #define GET_ITER(ts) ( (ts >> INVOCATION_SIZE) & 0xffffffffff)
 #define GET_INVOC(ts) ( ts & 0xf)
 
diff --git a/liberty/lib/SLAMP/SLAMPnng/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPnng/CMakeLists.txt
new file mode 100644
index 00000000..cb9f8144
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPnng/CMakeLists.txt
@@ -0,0 +1,32 @@
+file(GLOB SRCS
+    "*.cpp"
+)
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/nng/nng-1.5.2/install/lib/cmake")
+
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_nng")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+find_package(nng REQUIRED CONFIG)
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+include_directories(./
+        /u/ziyangx/test/nng/nng-1.5.2/install/include)
+
+add_library(${PassName} SHARED ${SRCS})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPnng/NngSend.cpp b/liberty/lib/SLAMP/SLAMPnng/NngSend.cpp
new file mode 100644
index 00000000..a571415d
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPnng/NngSend.cpp
@@ -0,0 +1,393 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "slamp_hooks.h"
+#include <nng/nng.h>
+#include <nng/protocol/pipeline0/pull.h>
+#include <nng/protocol/pipeline0/push.h>
+
+nng_socket sock;
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+  int rv;
+  int bytes;
+  char *url = "ipc:///tmp/SLAMP.ipc";
+  if ((rv = nng_push0_open(&sock)) != 0) {
+    fprintf(stderr, "nng_push0_open: %s", nng_strerror(rv));
+    exit(1);
+  }
+  if ((rv = nng_dial(sock, url, nullptr, 0)) != 0) {
+    fprintf(stderr, "nng_dial: %s", nng_strerror(rv));
+    exit(1);
+  }
+  // set NN_SNDBUF to 100MB
+  int sndbuf = 8192;
+  if ((rv = nng_setopt_int(sock, NNG_OPT_SENDBUF, sndbuf)) != 0) {
+    fprintf(stderr, "nng_setopt_int: %s", nng_strerror(rv));
+    exit(1);
+  }
+  // send a msg with "fn_id, loop_id"
+  char msg[100];
+  sprintf(msg, "%d,%d", fn_id, loop_id);
+  if ((rv = nng_send(sock, msg, strlen(msg), 0)) != 0) {
+    fprintf(stderr, "nng_send: %s", nng_strerror(rv));
+    exit(1);
+  }
+}
+
+void SLAMP_fini(const char* filename){
+  nng_close(sock);
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){}
+void SLAMP_exit_fcn(uint32_t id){}
+void SLAMP_enter_loop(uint32_t id){}
+void SLAMP_exit_loop(uint32_t id){}
+void SLAMP_loop_iter_ctx(uint32_t id){}
+void SLAMP_loop_invocation(){}
+void SLAMP_loop_iteration(){}
+void SLAMP_loop_exit(){}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){}
+void SLAMP_callback_stack_free(){}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  int rv;
+  char buf[1024];
+  // msg = instr + addr + value
+  sprintf(buf, "%d %lu %lu", instr, addr, value);
+
+  if ((rv = nng_send(sock, buf, strlen(buf), 0)) != 0) {
+    fprintf(stderr, "nng_send: %s", nng_strerror(rv));
+    exit(1);
+  }
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  int rv;
+  char buf[1024];
+  // msg = instr + addr + value
+  sprintf(buf, "%d %lu %lu", instr, addr, value);
+
+  if ((rv = nng_send(sock, buf, strlen(buf), 0)) != 0) {
+    fprintf(stderr, "nng_send: %s", nng_strerror(rv));
+    exit(1);
+  }
+
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  int rv;
+  char buf[1024];
+  // msg = instr + addr + value
+  sprintf(buf, "%d %lu %lu", instr, addr, value);
+
+  if ((rv = nng_send(sock, buf, strlen(buf), 0)) != 0) {
+    fprintf(stderr, "nng_send: %s", nng_strerror(rv));
+    exit(1);
+  }
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  int rv;
+  char buf[1024];
+  // msg = instr + addr + value
+  sprintf(buf, "%d %lu %lu", instr, addr, value);
+
+  if ((rv = nng_send(sock, buf, strlen(buf), 0)) != 0) {
+    fprintf(stderr, "nng_send: %s", nng_strerror(rv));
+    exit(1);
+  }
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){}
+void SLAMP_store2(uint32_t instr, const uint64_t addr){}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){}
+static void SLAMP_free_hook(void *ptr, const void *caller){}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+int* SLAMP___errno_location (void){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPnng/consumer/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPnng/consumer/CMakeLists.txt
new file mode 100644
index 00000000..89331c08
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPnng/consumer/CMakeLists.txt
@@ -0,0 +1,28 @@
+#
+# Copyright 2018 Capitar IT Group BV <info@capitar.com>
+# Copyright 2018 Staysail Systems, Inc. <info@staysail.tech>
+#
+# This software is supplied under the terms of the MIT License, a
+# copy of which should be located in the distribution where this
+# file was obtained (LICENSE.txt).  A copy of the license may also be
+# found online at https://opensource.org/licenses/MIT.
+
+cmake_minimum_required (VERSION 2.8.7)
+
+# add CMAKE_PREFIX_PATH
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/nng/nng-1.5.2/install/lib/cmake")
+project(raw)
+
+
+set(PARALLEL 128 CACHE STRING "Parallelism (min 4, max 1000)")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+find_package(nng CONFIG REQUIRED)
+
+add_executable(raw raw.c)
+target_link_libraries(raw nng::nng)
+target_compile_definitions(raw PRIVATE -DPARALLEL=${PARALLEL})
diff --git a/liberty/lib/SLAMP/SLAMPnng/consumer/raw.c b/liberty/lib/SLAMP/SLAMPnng/consumer/raw.c
new file mode 100644
index 00000000..ba231cbb
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPnng/consumer/raw.c
@@ -0,0 +1,82 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <nng/nng.h>
+#include <nng/protocol/pipeline0/pull.h>
+#include <nng/protocol/pipeline0/push.h>
+
+#define NODE0 "node0"
+#define NODE1 "node1"
+
+void
+fatal(const char *func, int rv)
+{
+        fprintf(stderr, "%s: %s\n", func, nng_strerror(rv));
+        exit(1);
+}
+
+int
+node0(const char *url)
+{
+        nng_socket sock;
+        int rv;
+
+        if ((rv = nng_pull0_open(&sock)) != 0) {
+                fatal("nng_pull0_open", rv);
+        }
+        if ((rv = nng_listen(sock, url, NULL, 0)) != 0) {
+                fatal("nng_listen", rv);
+        }
+        unsigned long counter = 0;
+        for (;;) {
+                char *buf = NULL;
+                size_t sz;
+                if ((rv = nng_recv(sock, &buf, &sz, NNG_FLAG_ALLOC)) != 0) {
+                        fatal("nng_recv", rv);
+                }
+                nng_free(buf, sz);
+                counter++;
+                if (counter % 1000000 == 0) {
+                        printf("node0: %lu\n", counter);
+                }
+        }
+}
+
+int
+node1(const char *url, char *msg)
+{
+        int sz_msg = strlen(msg) + 1; // '\0' too
+        nng_socket sock;
+        int rv;
+        int bytes;
+
+        if ((rv = nng_push0_open(&sock)) != 0) {
+                fatal("nng_push0_open", rv);
+        }
+        if ((rv = nng_dial(sock, url, NULL, 0)) != 0) {
+                fatal("nng_dial", rv);
+        }
+        printf("NODE1: SENDING \"%s\"\n", msg);
+        if ((rv = nng_send(sock, msg, strlen(msg)+1, 0)) != 0) {
+                fatal("nng_send", rv);
+        }
+        sleep(1); // wait for messages to flush before shutting down
+        nng_close(sock);
+        return (0);
+}
+
+int
+main(int argc, char **argv)
+{
+        if ((argc > 1) && (strcmp(NODE0, argv[1]) == 0))
+                return (node0(argv[2]));
+
+        if ((argc > 2) && (strcmp(NODE1, argv[1]) == 0))
+                return (node1(argv[2], argv[3]));
+
+        fprintf(stderr, "Usage: pipeline %s|%s <URL> <ARG> ...'\n",
+                NODE0, NODE1);
+        return (1);
+}
diff --git a/liberty/lib/SLAMP/SLAMPnng/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPnng/slamp_hooks.h
new file mode 100644
index 00000000..df546117
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPnng/slamp_hooks.h
@@ -0,0 +1,371 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPsmtxq/CMakeLists.txt
new file mode 100644
index 00000000..a8fcb5c0
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/CMakeLists.txt
@@ -0,0 +1,37 @@
+file(GLOB SRCS
+    "*.cpp"
+    "*.c"
+)
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+# set C++ flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-flto -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_smtx")
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+include_directories(./
+        /u/ziyangx/test/boost/boost_1_80_0/install/include)
+
+add_library(${PassName} STATIC ${SRCS})
+target_link_libraries(${PassName} ${Boost_LIBRARIES})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/SmtxSend.cpp b/liberty/lib/SLAMP/SLAMPsmtxq/SmtxSend.cpp
new file mode 100644
index 00000000..c412ce4c
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/SmtxSend.cpp
@@ -0,0 +1,661 @@
+#include "slamp_hooks.h"
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include <cstdio>
+#include <iostream>
+#include "malloc.h"
+
+#include <unistd.h>
+#include "sw_queue_astream.h"
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+namespace bip = boost::interprocess;
+
+// #define NO_SPECIAL
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment;
+bip::fixed_managed_shared_memory *segment2;
+static SW_Queue the_queue;
+
+#define CONSUME         sq_consume(the_queue);
+#define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+
+#define PRODUCE_2(x,y)  PRODUCE( (((uint64_t)x)<<32) | (uint32_t)(y) )
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+#define TURN_ON_HOOKS \
+  __malloc_hook = SLAMP_malloc_hook;\
+  __realloc_hook = SLAMP_realloc_hook;\
+  __memalign_hook = SLAMP_memalign_hook;
+
+
+#define TURN_OFF_HOOKS \
+  __malloc_hook = old_malloc_hook; \
+  __realloc_hook = old_realloc_hook; \
+  __memalign_hook = old_memalign_hook;
+
+// Ringbuffer fully constructed in shared memory. The element strings are
+// also allocated from the same shared memory segment. This vector can be
+// safely accessed from other processes.
+unsigned long counter_load = 0;
+unsigned long counter_store = 0;
+unsigned long counter_ctx = 0;
+unsigned long counter_alloc = 0;
+// char local_buffer[LOCAL_BUFFER_SIZE];
+// unsigned buffer_counter = 0;
+static int nested_level = 0;
+bool on_profiling = false;
+
+enum DepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    FINISHED,
+    FUNC_ENTRY,
+    FUNC_EXIT,
+    LOOP_ENTRY,
+    LOOP_EXIT,
+    LOOP_ITER_CTX,
+    POINTS_TO_INST,
+    POINTS_TO_ARG,
+    STACK_ALLOC,
+    STACK_FREE,
+    HEAP_FREE,
+};
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 32));
+  segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  if (the_queue == nullptr) {
+    std::cout << "Error: could not create queue" << std::endl;
+    exit(-1);
+  }
+  the_queue->data = data;
+  if (the_queue->data == nullptr) {
+    std::cout << "Error: could not create queue data" << std::endl;
+    exit(-1);
+  }
+
+  /* Initialize the queue data structure */
+  the_queue->p_data = (uint64_t) the_queue->data;
+  the_queue->c_inx = 0;
+  the_queue->c_margin = 0;
+  the_queue->p_glb_inx = 0;
+  the_queue->c_glb_inx = 0;
+  the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+  // local_buffer = new LocalBuffer(queue);
+
+  // send a msg with "fn_id, loop_id"
+  // char msg[100];
+  // sprintf(msg, "%d,%d", fn_id, loop_id);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+
+  // local_buffer->push(INIT);
+  // local_buffer->push(loop_id);
+  //
+  setlocale(LC_ALL,"");
+  PRODUCE_2(INIT, loop_id);
+  uint32_t pid = getpid();
+  printf("SLAMP_init: %d, %d, %d\n", fn_id, loop_id, pid);
+  // local_buffer->push(pid);
+  PRODUCE(pid);
+
+  auto allocateLibcReqs = [](void *addr, size_t size) {
+    PRODUCE_2(ALLOC, size);
+    PRODUCE((uint64_t)addr);
+  };
+
+  allocateLibcReqs((void*)&errno, sizeof(errno));
+  allocateLibcReqs((void*)&stdin, sizeof(stdin));
+  allocateLibcReqs((void*)&stdout, sizeof(stdout));
+  allocateLibcReqs((void*)&stderr, sizeof(stderr));
+  allocateLibcReqs((void*)&sys_nerr, sizeof(sys_nerr));
+
+  // const unsigned short int* ctype_ptr = (*__ctype_b_loc()) - 128;
+  // allocateLibcReqs((void*)ctype_ptr, 384 * sizeof(*ctype_ptr));
+  // const int32_t* itype_ptr = (*__ctype_tolower_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+  // itype_ptr = (*__ctype_toupper_loc()) - 128;
+  // allocateLibcReqs((void*)itype_ptr, 384 * sizeof(*itype_ptr));
+
+  old_malloc_hook = __malloc_hook;
+  // old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+  __malloc_hook = SLAMP_malloc_hook;
+  __free_hook = nullptr;
+  __realloc_hook = SLAMP_realloc_hook;
+  // __free_hook = SLAMP_free_hook;
+  __memalign_hook = SLAMP_memalign_hook;
+}
+
+void SLAMP_fini(const char* filename){
+  // send a msg with "fini"
+  // queue->push(shm::shared_string("fini", *char_alloc));
+  std::cout << counter_load << " " << counter_store << " " << counter_ctx << std::endl;
+  // local_buffer->push(FINISHED);
+  // local_buffer->flush();
+  PRODUCE_2(FINISHED, 0);
+  sq_flushQueue(the_queue);
+}
+
+void SLAMP_allocated(uint64_t addr){}
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  // local_buffer->push(ALLOC)->push(addr)->push(size);
+  PRODUCE_2(ALLOC, size);
+  PRODUCE(addr);
+}
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){
+#ifdef NO_SPECIAL
+  PRODUCE_2(FUNC_ENTRY, id);
+#endif
+}
+void SLAMP_exit_fcn(uint32_t id){
+#ifdef NO_SPECIAL
+  PRODUCE_2(FUNC_EXIT, id);
+#endif
+}
+void SLAMP_enter_loop(uint32_t id){
+#ifdef NO_SPECIAL
+  PRODUCE_2(LOOP_ENTRY, id);
+#endif
+}
+void SLAMP_exit_loop(uint32_t id){
+#ifdef NO_SPECIAL
+  PRODUCE_2(LOOP_EXIT, id);
+#endif
+}
+void SLAMP_loop_iter_ctx(uint32_t id){
+#ifdef NO_SPECIAL
+  PRODUCE_2(LOOP_ITER_CTX, id);
+#endif
+}
+void SLAMP_loop_invocation(){
+  // send a msg with "loop_invocation"
+  // local_buffer->push(LOOP_INVOC);
+  PRODUCE_2(LOOP_INVOC, 0);
+
+  counter_ctx++;
+  on_profiling = true;
+  nested_level++;
+  on_profiling = true;
+}
+void SLAMP_loop_iteration(){
+  // local_buffer->push(LOOP_ITER);
+  PRODUCE_2(LOOP_ITER, 0);
+  counter_ctx++;
+}
+
+void SLAMP_loop_exit(){
+  nested_level--;
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t fcnId, uint32_t argId, void *ptr){
+  uint32_t id = (fcnId << 16) | (argId & 0xffff);
+#ifdef NO_SPECIAL
+  PRODUCE_2(POINTS_TO_ARG, id);
+  PRODUCE((uint64_t)ptr);
+#endif
+}
+void SLAMP_report_base_pointer_inst(uint32_t instId, void *ptr){
+#ifdef NO_SPECIAL
+  PRODUCE_2(POINTS_TO_INST, instId);
+  PRODUCE((uint64_t)ptr);
+#endif
+}
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t){
+#ifdef NO_SPECIAL
+  PRODUCE_2(STACK_ALLOC, 0);
+#endif
+}
+void SLAMP_callback_stack_free(){
+#ifdef NO_SPECIAL
+  PRODUCE_2(STACK_FREE, 0);
+#endif
+}
+
+void SLAMP_ext_push(const uint32_t instr){}
+void SLAMP_ext_pop(){}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline) {
+  // send a msg with "load, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "load,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  //
+  if (on_profiling) {
+    // local_buffer->push(LOAD)->push(instr)->push(addr)->push(bare_instr); //->push(value);
+    PRODUCE_2(LOAD, instr);
+    PRODUCE(addr);
+    // PRODUCE(value);
+    counter_load++;
+  }
+}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load(instr, addr, bare_instr, value);
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_load(instr, addr, bare_instr, 0);
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load1(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load2(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load4(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  SLAMP_load8(bare_instr, addr, bare_instr, value);
+}
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  SLAMP_loadn(bare_instr, addr, bare_instr, n);
+}
+
+void SLAMP_store(const uint32_t instr, const uint64_t addr, const uint32_t bare_instr) ATTRIBUTE(always_inline) {
+  // send a msg with "store, instr, addr, bare_instr, value"
+  // char msg[100];
+  // sprintf(msg, "store,%d,%lu,%d,%lu", instr, addr, bare_instr, value);
+  // queue->push(shm::shared_string(msg, *char_alloc));
+  if (on_profiling) {
+    // local_buffer->push(STORE)->push(instr)->push(bare_instr)->push(addr);
+    PRODUCE_2(STORE, instr);
+    // PRODUCE(instr);
+    // PRODUCE(bare_instr);
+    // PRODUCE_2(instr, bare_instr);
+    PRODUCE(addr);
+    counter_store++;
+  }
+}
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  SLAMP_store(instr, addr, instr);
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  SLAMP_store(instr, addr, instr);
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store1(bare_inst, addr);
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store2(bare_inst, addr);
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store4(bare_inst, addr);
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  SLAMP_store8(bare_inst, addr);
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  SLAMP_storen(bare_inst, addr, n);
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = malloc(size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  PRODUCE_2(ALLOC, size);
+  PRODUCE((uint64_t)ptr);
+  // printf("malloc %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* new_ptr = realloc(ptr, size);
+  // local_buffer->push(REALLOC)->push((uint64_t)ptr)->push((uint64_t)new_ptr)->push(size);
+  PRODUCE_2(ALLOC, size);
+  PRODUCE((uint64_t)new_ptr);
+  // printf("realloc %p to %lu at %p", ptr, size, new_ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return new_ptr;
+}
+
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  TURN_OFF_HOOKS
+  free(ptr);
+#ifdef NO_SPECIAL
+  PRODUCE_2(HEAP_FREE, 0);
+  PRODUCE((uint64_t)ptr);
+#endif
+  TURN_ON_HOOKS
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  TURN_OFF_HOOKS
+  void* ptr = memalign(alignment, size);
+  // local_buffer->push(ALLOC)->push((uint64_t)ptr)->push(size);
+  PRODUCE_2(ALLOC, size);
+  PRODUCE((uint64_t)ptr);
+
+  // printf("memalign %lu at %p\n", size, ptr);
+  counter_alloc++;
+  TURN_ON_HOOKS
+  return ptr;
+}
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){
+  // void* ptr = malloc(size);
+  // // send a msg with "malloc, instr, ptr, size, alignment"
+  // // char msg[100];
+  // // sprintf(msg, "malloc,%d,%lu,%lu,%lu", instr, ptr, size, alignment);
+  // // queue->push(shm::shared_string(msg, *char_alloc));
+  // queue->push(ALLOC);
+  // queue->push(reinterpret_cast<uint64_t>(ptr));
+  // queue->push(size);
+  // counter_alloc++;
+  // return ptr;
+}
+
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/bitcast.h b/liberty/lib/SLAMP/SLAMPsmtxq/bitcast.h
new file mode 100644
index 00000000..404a9a99
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/bitcast.h
@@ -0,0 +1,29 @@
+#ifndef BITCAST_H
+#define BITCAST_H
+
+typedef union { double d; int64_t i; } SQ_DI;
+typedef union { float f; int32_t i; } SQ_FI;
+
+Inline int64_t doubleToInt(double d) {
+  SQ_DI conv;
+  conv.d = d;
+  return conv.i;
+}
+Inline int64_t floatToInt(float f) {
+  SQ_FI conv;
+  conv.f = f;
+  return conv.i;
+}
+Inline double intToDouble(int64_t i) {
+  SQ_DI conv;
+  conv.i = (int32_t)i;
+  return conv.d;
+}
+
+Inline float intToFloat(int64_t i) {
+  SQ_FI conv;
+  conv.i = (int32_t)i;
+  return conv.f;
+}
+
+#endif /* BITCAST_H */
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/.gitignore b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/.gitignore
new file mode 100644
index 00000000..378eac25
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/CMakeLists.txt
new file mode 100644
index 00000000..74a6c20f
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required (VERSION 3.6.2 FATAL_ERROR)
+
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+set(CMAKE_LINKER "ld.gold")
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} "/u/ziyangx/test/boost/boost_1_80_0/install/lib/cmake")
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto -Ofast")
+set(LINK_FLAGS "${LINK_FLAGS} -flto -O3")
+
+find_package(Boost 1.80.0 REQUIRED COMPONENTS system)
+include_directories(${Boost_INCLUDE_DIRS})
+include_directories(./
+    ../)
+
+add_executable (consumer consumer.cpp ../sw_queue.c ProfilingModules/DependenceModule.cpp)
+target_link_libraries(consumer LINK_PUBLIC 
+	${Boost_LIBRARIES}
+	rt
+	Threads::Threads
+)
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules
new file mode 120000
index 00000000..ff3f9738
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules
@@ -0,0 +1 @@
+../../SLAMPcustom/consumer/ProfilingModules
\ No newline at end of file
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.cpp b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.cpp
new file mode 100644
index 00000000..105143f3
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.cpp
@@ -0,0 +1,326 @@
+#include <cstdint>
+#include <set>
+#include <thread>
+#include <vector>
+#include <unordered_set>
+#include <fstream>
+
+#include "slamp_timestamp.h"
+#include "slamp_logger.h"
+#include "slamp_shadow_mem.h"
+#include "DependenceModule.h"
+#include <mutex>
+
+std::mutex m;
+std::mutex mutex_process_load_store;
+
+constexpr unsigned LOCALWRITE_THREADS = 1;
+std::mutex localwrite_mutexes[LOCALWRITE_THREADS];
+
+#define SIZE_8M  0x800000
+
+#define DEPLOG_VEC_SIZE 1'000'000
+
+static slamp::MemoryMap* smmap = nullptr;
+static std::unordered_set<slamp::KEY, slamp::KEYHash, slamp::KEYEqual> *deplog_set;
+static std::vector<slamp::KEY> *deplog_vec[LOCALWRITE_THREADS];
+static uint64_t slamp_iteration = 0;
+static uint64_t slamp_invocation = 0;
+static uint32_t target_loop_id = 0;
+
+struct LoadStoreEvent {
+  // bool isLoad;
+  uint64_t addr;
+  // uint64_t value;
+  TS ts;
+  // uint32_t instr;
+  // uint32_t bare_instr;
+  // uint64_t invocation;
+  // uint64_t iteration;
+};
+// constexpr unsigned MAX_EVENTS = 100'000'000;
+constexpr unsigned MAX_EVENTS = 100'000;
+static std::vector<LoadStoreEvent> *loadstore_vec, *loadstore_vec0, *loadstore_vec1;
+static uint64_t loadstore_vec_counter = 0;
+
+static std::chrono::duration<long, std::micro> total_time_off_critical_path(0);
+static std::chrono::duration<long, std::micro> loadstore_vec_time(0);
+
+static void convertVectorToSet(const unsigned thread_id) {
+
+  // launch 56 threads to convert the vector to set independently, chunking
+  constexpr auto THREADS = 56;
+  std::thread t[THREADS];
+  for (unsigned long i = 0; i < THREADS; i++) {
+    t[i] = std::thread(
+        [&](int id) {
+          // take the chunk and convert to a set and return
+          auto *deplog_set_chunk =
+              new std::unordered_set<slamp::KEY, slamp::KEYHash,
+                                     slamp::KEYEqual>();
+          deplog_set_chunk->reserve(DEPLOG_VEC_SIZE / THREADS + 1);
+          auto begin = id * (DEPLOG_VEC_SIZE / THREADS);
+          auto end = (id + 1) * (DEPLOG_VEC_SIZE / THREADS);
+          deplog_set_chunk->insert(deplog_vec[thread_id]->begin() + begin,
+                                   deplog_vec[thread_id]->begin() + end);
+
+          m.lock();
+          // lock the global set and insert the chunk
+          deplog_set->insert(deplog_set_chunk->begin(),
+                             deplog_set_chunk->end());
+          m.unlock();
+          delete deplog_set_chunk;
+        },
+        i);
+  }
+  // join the threads
+  for (auto &i : t) {
+    i.join();
+  }
+
+  // std::cout << "Merging vec to set, set length " << deplog_set->size()
+            // << std::endl;
+}
+
+
+namespace DepMod {
+// init: setup the shadow memory
+void init(uint32_t loop_id, uint32_t pid) {
+
+  target_loop_id = loop_id;
+  smmap = new slamp::MemoryMap(TIMESTAMP_SIZE_IN_BYTES);
+  deplog_set = new std::unordered_set<slamp::KEY, slamp::KEYHash, slamp::KEYEqual>();
+  for (auto & i : deplog_vec) {
+    i = new std::vector<slamp::KEY>();
+    i->reserve(DEPLOG_VEC_SIZE);
+  }
+
+  loadstore_vec0 = new std::vector<LoadStoreEvent>();
+  loadstore_vec1 = new std::vector<LoadStoreEvent>();
+  loadstore_vec = loadstore_vec0; // double buffering
+  loadstore_vec0->reserve(MAX_EVENTS);
+  loadstore_vec1->reserve(MAX_EVENTS);
+
+  smmap->init_stack(SIZE_8M, pid);
+}
+
+void handleLoadAndStore(std::vector<LoadStoreEvent> *loadstore_vec);
+
+void fini(const char *filename) {
+  // show in seconds
+  std::cout << "Total time off critical path: "
+            << total_time_off_critical_path.count() / 1000000.0 << "s"
+            << std::endl;
+
+  std::cout << "Loadstore vec time: "
+    << loadstore_vec_time.count() / 1000000.0 << "s"
+    << std::endl;
+
+  mutex_process_load_store.lock();
+  handleLoadAndStore(loadstore_vec);
+  for (int i = 0; i < LOCALWRITE_THREADS; i++) {
+    convertVectorToSet(i);
+  }
+  std::ofstream of(filename);
+  of << target_loop_id << " " << 0 << " " << 0 << " "
+       << 0 << " " << 0 << " " << 0 << "\n";
+
+  std::set<slamp::KEY, slamp::KEYComp> ordered(deplog_set->begin(), deplog_set->end());
+  for (auto &k: ordered) {
+    of << target_loop_id << " " << k.src << " " << k.dst << " " << k.dst_bare << " "
+       << (k.cross ? 1 : 0) << " " << 1 << " ";
+    of << "\n";
+  }
+
+  delete smmap;
+  delete deplog_set;
+}
+
+void allocate(void *addr, uint64_t size) {
+  smmap->allocate(addr, size);
+  // std::cout << "allocate " << addr << " " << size << std::endl;
+}
+
+
+// void log(TS ts, const uint32_t dst_inst, TS *pts, const uint32_t bare_inst,
+         // uint64_t  addr, uint64_t  value, uint8_t  size) {
+void log(const unsigned thread_id, TS ts, const uint32_t dst_inst, const uint32_t bare_inst, const uint64_t load_invocation, const uint64_t load_iteration){ 
+
+    uint32_t src_inst = GET_INSTR(ts);
+
+    uint64_t src_invoc = GET_INVOC(ts);
+    uint64_t src_iter = GET_ITER(ts);
+
+    if (src_invoc != GET_INVOC(load_invocation)) {
+      return;
+    }
+
+    // uint64_t src_invoc = GET_INVOC(ts);
+
+    slamp::KEY key(src_inst, dst_inst, bare_inst, src_iter != load_iteration);
+    
+    // std::cout << "src_inst: " << src_inst << " dst_inst: " << dst_inst << " bare_inst: " << bare_inst << " src_iter: " << src_iter << " slamp_iteration: " << slamp_iteration << " src_iter != slamp_iteration: " << (src_iter != slamp_iteration) << std::endl;
+    deplog_vec[thread_id]->emplace_back(key);
+    if (deplog_vec[thread_id]->size() == DEPLOG_VEC_SIZE - 1) {
+      convertVectorToSet(thread_id);
+      deplog_vec[thread_id]->resize(0);
+    }
+}
+
+void handleLoadAndStore(std::vector<LoadStoreEvent> *loadstore_vec) {
+
+  // put in LOCALWRITE_THREADS threads to handle the loadstore_vec
+  std::thread t[LOCALWRITE_THREADS];
+
+  for (auto i = 0; i < LOCALWRITE_THREADS; i++) {
+    unsigned begin = i * (loadstore_vec_counter / LOCALWRITE_THREADS);
+    unsigned end = (i + 1) * (loadstore_vec_counter / LOCALWRITE_THREADS);
+    unsigned thread_id = 0;
+    // t[i] = std::thread(
+        // [&](const unsigned thread_id, const unsigned begin, const unsigned end) {
+          for (auto i = begin; i < end; i++) {
+            auto &e = (*loadstore_vec)[i];
+            const auto &addr = e.addr;
+            const auto &ts = e.ts;
+            const auto invoc = GET_INVOC(ts);
+            const auto iter = GET_ITER(ts);
+            const auto instr = GET_INSTR(ts);
+
+            TS *s = (TS *)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+            // if (e.isLoad) {
+            // load
+            // std::cout << "load " << e.addr << " " << e.value << " " <<
+            // e.instr
+            // << " " << e.bare_instr << std::endl; smmap->load(e.addr,
+            // e.value, e.instr, e.bare_instr);
+
+            // std::cout << "load " << instr << " " << addr << " " <<
+            // bare_instr
+            // << " "
+            // << value << std::endl;
+            TS tss = s[0];
+            if (tss != 0) {
+              log(thread_id, tss, instr, instr, invoc, iter);
+            }
+            // }
+            // else {
+            // // store
+            // // std::cout << "store " << e.addr << " " << e.value << " " <<
+            // // e.instr
+            // // << " " << e.bare_instr << std::endl; smmap->store(e.addr,
+            // // e.value, e.instr, e.bare_instr);
+            // // if (!smmap->is_allocated(s)) {
+            // //   std::cout << "store not allocated: " << instr << " " <<
+            // //   bare_instr << " " << addr << std::endl;
+            // // }
+            // // TODO: handle output dependence. ignore it as of now.
+            // // if (ASSUME_ONE_ADDR) {
+            // s[0] = ts;
+            // // } else {
+            // // for (auto i = 0; i < size; i++)
+            // // s[i] = ts;
+            // // }
+            // }
+          }
+        // }, i, begin, end);
+  }
+
+  // for (auto & i : t) {
+    // i.join();
+  // }
+  // mutex_process_load_store.unlock();
+}
+
+
+// template <unsigned size>
+void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) {
+
+  TS *s = (TS *)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+  // if (e.isLoad) {
+  // load
+  // std::cout << "load " << e.addr << " " << e.value << " " <<
+  // e.instr
+  // << " " << e.bare_instr << std::endl; smmap->load(e.addr,
+  // e.value, e.instr, e.bare_instr);
+
+  // std::cout << "load " << instr << " " << addr << " " <<
+  // bare_instr
+  // << " "
+  // << value << std::endl;
+  TS tss = s[0];
+  if (tss != 0) {
+    log(0, tss, instr, instr, slamp_invocation, slamp_iteration);
+  }
+  // // auto start = std::chrono::high_resolution_clock::now();
+  // loadstore_vec->emplace_back(LoadStoreEvent{addr, CREATE_TS(instr, slamp_iteration, slamp_invocation)});
+  // loadstore_vec_counter++;
+  // // auto end = std::chrono::high_resolution_clock::now();
+  // // auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+  // // loadstore_vec_time += duration;
+  // if (loadstore_vec_counter == MAX_EVENTS - 1) {
+  //   handleLoadAndStore(loadstore_vec);
+
+  //   // // measure time in here
+  //   // auto start = std::chrono::high_resolution_clock::now();
+
+  //   // // run this asynchrously
+  //   // mutex_process_load_store.lock();
+  //   // std::thread t = std::thread(handleLoadAndStore, loadstore_vec);
+  //   // t.detach();
+
+  //   // // swap double buffer
+  //   // loadstore_vec = loadstore_vec == loadstore_vec0 ? loadstore_vec1 : loadstore_vec0;
+    
+  //   // loadstore_vec->resize(0);
+  //   // loadstore_vec_counter = 0;
+
+  //   // auto end = std::chrono::high_resolution_clock::now();
+  //   // auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+  //   // total_time_off_critical_path += duration;
+  // }
+
+}
+
+// template <unsigned size>
+void store(uint32_t instr, uint32_t bare_instr, const uint64_t addr) {
+  // if (loadstore_vec_counter > 0) {
+  //   handleLoadAndStore(loadstore_vec);
+  //   loadstore_vec->resize(0);
+  //   loadstore_vec_counter = 0;
+  // }
+
+  TS ts = CREATE_TS(instr, slamp_iteration, slamp_invocation);
+  TS *shadow_addr = (TS *)GET_SHADOW(addr, TIMESTAMP_SIZE_IN_POWER_OF_TWO);
+  shadow_addr[0] = ts;
+
+  // // auto start = std::chrono::high_resolution_clock::now();
+  // loadstore_vec->emplace_back(LoadStoreEvent{false, addr, CREATE_TS(instr, slamp_iteration, slamp_invocation)});
+  // loadstore_vec_counter++;
+  // // auto end = std::chrono::high_resolution_clock::now();
+  // // auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+  // // loadstore_vec_time += duration;
+  // if (loadstore_vec_counter == MAX_EVENTS - 1) {
+  //   // measure time in here
+  //   auto start = std::chrono::high_resolution_clock::now();
+  //   mutex_process_load_store.lock();
+  //   std::thread t = std::thread(handleLoadAndStore, loadstore_vec);
+  //   t.detach();
+  //   loadstore_vec = loadstore_vec == loadstore_vec0 ? loadstore_vec1 : loadstore_vec0;
+
+  //   loadstore_vec->resize(0);
+  //   loadstore_vec_counter = 0;
+  //   auto end = std::chrono::high_resolution_clock::now();
+  //   auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+  //   total_time_off_critical_path += duration;
+  // }
+}
+
+void loop_invoc() {
+  slamp_iteration = 0;
+  slamp_invocation++;
+}
+
+void loop_iter() {
+  slamp_iteration++;
+}
+} // namespace DepMod
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.h b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.h
new file mode 100644
index 00000000..a2664cdc
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/DependenceModule.h
@@ -0,0 +1,23 @@
+#include <cstdint>
+
+namespace DepMod {
+void init(uint32_t loop_id, uint32_t pid);
+void fini(const char *filename);
+void load(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value);
+void store(uint32_t instr, uint32_t bare_instr, const uint64_t addr);
+void allocate(void *addr, uint64_t size);
+void loop_invoc();
+void loop_iter();
+
+enum DepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    FINISHED
+};
+
+} // namespace DepMod
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_bound_malloc.h b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_bound_malloc.h
new file mode 100644
index 00000000..0d6b9410
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_bound_malloc.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+#define SLAMPLIB_HOOKS_SLAMP_BOUND_MALLOC_H
+
+#include <cstddef>
+#include <cstdint>
+namespace slamp 
+{
+
+void init_bound_malloc(void* heap_bound);
+void fini_bound_malloc();
+
+size_t get_object_size(void* ptr);
+
+void* bound_malloc(size_t size, size_t alignment=16);
+bool bound_free(void *ptr, uint64_t &starting_page, unsigned &purge_cnt);
+void* bound_calloc(size_t num, size_t size);
+void* bound_realloc(void* ptr, size_t size);
+void  bound_discard_page();
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_logger.h b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_logger.h
new file mode 100644
index 00000000..89641a03
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_logger.h
@@ -0,0 +1,110 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_LOGGER
+#define SLAMPLIB_HOOKS_SLAMP_LOGGER
+
+#include <cstdint>
+#include <stdint.h>
+#include <stdlib.h>
+#include <functional>
+
+#include "slamp_timestamp.h"
+
+namespace slamp
+{
+
+struct KEY
+{
+  uint32_t src;
+  uint32_t dst;
+  uint32_t dst_bare;
+  uint32_t cross;
+
+  KEY() {}
+  KEY(uint32_t s, uint32_t d, uint32_t b, uint32_t c) : src(s), dst(d), dst_bare(b), cross(c) {}
+};
+
+struct KEYHash
+{
+  size_t operator()(const KEY& key) const
+  {
+    static_assert(sizeof(size_t) == sizeof(uint64_t), "Should be 64bit address");
+    std::hash<uint64_t> hash_fn;
+
+    // hash(32-32) ^ hash(32-1)
+    // FIXME: find a better hash function
+    return hash_fn(((uint64_t)key.src << 32) | key.dst) ^ hash_fn(((uint64_t)key.dst_bare << 1) | (key.cross & 0x1));
+  }
+};
+
+struct KEYComp
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if (src1 < src2)
+      return true;
+    else if (src1 > src2)
+      return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if (dst1 < dst2)
+      return true;
+    else if (dst1 > dst2)
+      return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if (dst_bare1 < dst_bare2)
+      return true;
+    else if (dst_bare1 > dst_bare2)
+      return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    return cross1 < cross2;
+  }
+};
+
+struct KEYEqual
+{
+  bool operator()(const KEY& key1, const KEY& key2) const
+  {
+    uint32_t src1 = key1.src;
+    uint32_t src2 = key2.src;
+
+    if ( src1 != src2 ) return false;
+
+    uint32_t dst1 = key1.dst;
+    uint32_t dst2 = key2.dst;
+
+    if ( dst1 != dst2 ) return false;
+
+    uint32_t dst_bare1 = key1.dst_bare;
+    uint32_t dst_bare2 = key2.dst_bare;
+
+    if ( dst_bare1 != dst_bare2 ) return false;
+
+    uint32_t cross1 = key1.cross;
+    uint32_t cross2 = key2.cross;
+
+    if ( cross1 != cross2 ) return false;
+
+    return true;
+  }
+};
+
+
+void init_logger(uint32_t fn_id, uint32_t loop_id);
+void fini_logger(const char* filename);
+
+uint32_t log(TS ts, const uint32_t dst_instr, TS* pts, const uint32_t bare_inst, uint64_t addr, uint64_t value, uint8_t size);
+void print_log(const char* filename);
+
+}
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_shadow_mem.h b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_shadow_mem.h
new file mode 100644
index 00000000..ef07201b
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_shadow_mem.h
@@ -0,0 +1,197 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+#define SLAMPLIB_HOOKS_SLAMP_SHADOW_MEM_H
+
+#include <cassert>
+#include <csignal>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <set>
+#include <unordered_map>
+
+// higher half of canonical region cannot be used
+
+/// left shift by `shift`, mask 47 LSB, toggle #45 bit?
+#define MASK1 0x00007fffffffffffL
+#define MASK2 0x0000200000000000L
+#define GET_SHADOW(addr, shift)                                                \
+  (((((uint64_t)(addr)) << (shift)) & MASK1) ^ MASK2)
+
+namespace slamp {
+
+class MemoryMap {
+public:
+  uint64_t heapStart = 0;
+  MemoryMap(unsigned r) : ratio(r), ratio_shift(0) {
+    // ratio expected to be a power of 2
+    assert((r & (r - 1)) == 0);
+
+    // log(r)
+    unsigned n = r;
+    while ((n & 1) == 0) {
+      this->ratio_shift += 1;
+      n = n >> 1;
+    }
+
+    // get the page size of the host system
+    pagesize = getpagesize();
+    pagemask = ~(pagesize - 1);
+  }
+
+  ~MemoryMap() {
+    // freeing all remaining shadow addresses
+    for (auto page : pages) {
+      uint64_t s = GET_SHADOW(page, ratio_shift);
+      munmap(reinterpret_cast<void *>(s), pagesize * ratio);
+    }
+  }
+
+  unsigned get_ratio() { return ratio; }
+
+  bool is_allocated(void *addr) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t page = a & pagemask;
+    if (pages.find(page) != pages.end())
+      return true;
+    else
+      return false;
+  }
+
+  /// allocate shadow page if not exist
+  void *allocate(void *addr, size_t size) {
+    auto a = reinterpret_cast<uint64_t>(addr);
+    uint64_t pagebegin = a & pagemask;
+    uint64_t pageend = (a + size - 1) & pagemask;
+
+    // try mmap
+
+    std::set<void *> shadow_pages;
+    bool success = true;
+
+    for (uint64_t page = pagebegin; page <= pageend; page += pagesize) {
+      if (pages.find(page) != pages.end())
+        continue;
+
+      uint64_t s = GET_SHADOW(page, ratio_shift);
+      // create a shadow page for the page
+      void *p = mmap(reinterpret_cast<void *>(s), pagesize * ratio,
+                     PROT_WRITE | PROT_READ,
+                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+      if (p == MAP_FAILED) {
+        int err = errno;
+        printf("mmap failed: %lx errno: %d\n", s, err);
+        raise(SIGINT);
+
+        success = false;
+        break;
+      } else {
+        shadow_pages.insert(p);
+      }
+    }
+
+    if (success) {
+      for (uint64_t page = pagebegin; page <= pageend; page += pagesize)
+        pages.insert(page);
+      uint64_t pagebegin = a & pagemask;
+      uint64_t pageend = (a + size - 1) & pagemask;
+
+      // return shadow_mem
+      auto *shadow_addr = (uint64_t *)GET_SHADOW(a, ratio_shift);
+      return (void *)(shadow_addr);
+    } else {
+      // cleanup
+      for (auto shadow_page : shadow_pages)
+        munmap(shadow_page, pagesize * ratio);
+      return nullptr;
+    }
+  }
+
+  // free the shadow pages
+  void deallocate_pages(uint64_t page, unsigned cnt) {
+    munmap(reinterpret_cast<void *>(GET_SHADOW(page, ratio_shift)),
+           pagesize * ratio * cnt);
+
+    // fprintf(stderr, "deallocate_pages: %lx %d\n", GET_SHADOW(page, ratio_shift), cnt);
+
+    for (auto i = 0; i < cnt; i++, page += pagesize)
+      pages.erase(page);
+  }
+
+  /// for realloc; the dependence carries over
+  void copy(void *dst, void *src, size_t size) {
+    size_t shadow_size = size * ratio;
+    void *shadow_dst = (void *)GET_SHADOW(dst, ratio_shift);
+    void *shadow_src = (void *)GET_SHADOW(src, ratio_shift);
+    memcpy(shadow_dst, shadow_src, shadow_size);
+  }
+
+  void init_heap(void *addr) {
+    heapStart = reinterpret_cast<uint64_t>(addr);
+  }
+
+  // init stack size to be fixed 8MB
+  // the stack in /proc/$pid/maps changes in runtime, use it to find the end
+  void init_stack(uint64_t stack_size, uint64_t pid) {
+    char filename[256];
+    char buf[5000];
+    sprintf(filename, "/proc/%lu/maps", pid);
+    // sprintf(filename, "/proc/%u/maps", getpid());
+
+    FILE *fp = fopen(filename, "r");
+    if (!fp) {
+      perror(filename);
+      exit(EXIT_FAILURE);
+    }
+
+    bool allocated = false;
+
+    while (fgets(buf, sizeof(buf), fp) != nullptr) {
+      uint64_t start, end;
+      char name[5000];
+
+      int n = sscanf(buf, "%lx-%lx %*c%*c%*c%*c %*llx %*x:%*x %*lu %s", &start,
+                     &end, name);
+
+      if (n != 3) {
+        continue;
+      }
+
+      // FIXME: get heap start addr
+      if (!strcmp(name, "[heap]")) {
+        heapStart = start;
+      }
+
+
+      if (!strcmp(name, "[stack]")) {
+        // stack grow from end (big address) backwards
+        // print the stack start and end
+        printf("stack: %lx %lx\n", end - stack_size, end);
+        allocate(reinterpret_cast<void *>(end - stack_size), stack_size);
+        allocated = true;
+        break;
+      }
+    }
+
+    if (!allocated) {
+      fprintf(stderr, "Error: failed to allocate shadow for stack");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+private:
+  std::set<uint64_t> pages; // page table
+
+  unsigned ratio; // (size of metadata) / (size of real data)
+  unsigned ratio_shift;
+  uint64_t pagesize;
+  uint64_t pagemask;
+};
+
+} // namespace slamp
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_timestamp.h b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_timestamp.h
new file mode 100644
index 00000000..b8ec4673
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/ProfilingModules_old/slamp_timestamp.h
@@ -0,0 +1,22 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+#define SLAMPLIB_HOOKS_SLAMP_TIMESTAMP
+
+#include <stdint.h>
+
+typedef uint64_t TS; // first 20 bits for instr and following 44 bits for iter
+#define TIMESTAMP_SIZE_IN_BYTES 8
+#define TIMESTAMP_SIZE_IN_POWER_OF_TWO 3
+#define ITERATION_SIZE 28 
+#define INVOCATION_SIZE 16 // 44-40
+#define CREATE_TS(instr, iter, invoc) ( ((TS)instr << 44) | (((TS)iter & (TS)0xfffffff) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xffff))
+// #define CREATE_TS_HASH(instr, hash, iter, invoc)                               \
+  // (((TS)instr << 44) |                                                         \
+   // (((TS)hash & (TS)0xfffffffff) << (INVOCATION_SIZE + 4)) |                   \
+   // (((TS)iter & (TS)0xf) << INVOCATION_SIZE) | ((TS)invoc & (TS)0xf))
+#define GET_INSTR(ts) ((ts >> 44) & 0xfffff)
+#define GET_HASH(ts) ( (ts >> 8) & 0xfffffffff)
+#define GET_ITER(ts) ( (ts >> INVOCATION_SIZE) & 0xfffffff)
+#define GET_INVOC(ts) ( ts & 0xffff)
+
+
+#endif
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/consumer/consumer.cpp b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/consumer.cpp
new file mode 100644
index 00000000..d37c889e
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/consumer/consumer.cpp
@@ -0,0 +1,233 @@
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <cstdint>
+#include "ProfilingModules/DependenceModule.h"
+#include <iostream>
+#include <sstream>
+#include "sw_queue_astream.h"
+
+
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+namespace bip = boost::interprocess;
+
+#define DEBUG 0
+#define ACTION 1
+
+// create segment and corresponding allocator
+bip::fixed_managed_shared_memory *segment, *segment2;
+static SW_Queue the_queue;
+
+#define CONSUME         sq_consume(the_queue);
+#define PRODUCE(x)      sq_produce(the_queue,(uint64_t)x);
+
+#define PRODUCE_2(x,y)  PRODUCE( (((uint64_t)x)<<32) | (uint32_t)(y) )
+#define CONSUME_2(x,y)  do { uint64_t tmp = CONSUME; x = (uint32_t)(tmp>>32); y = (uint32_t) tmp; } while(0)
+
+
+enum class NewDepModAction: char
+{
+    INIT = 0,
+    LOAD,
+    STORE,
+    ALLOC,
+    LOOP_INVOC,
+    LOOP_ITER,
+    FINISHED,
+    FUNC_ENTRY,
+    FUNC_EXIT,
+    LOOP_ENTRY,
+    LOOP_EXIT,
+    LOOP_ITER_CTX,
+    POINTS_TO_INST,
+    POINTS_TO_ARG,
+    STACK_ALLOC,
+    STACK_FREE,
+    HEAP_FREE,
+};
+
+int main() {
+  segment = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 32));
+  segment2 = new bip::fixed_managed_shared_memory(bip::open_or_create, "MySharedMemory2", sizeof(uint64_t) *QSIZE *2, (void*)(1UL << 28));
+    // managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  auto data = static_cast<uint64_t*>(segment2->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  // segment = new bip::managed_shared_memory(bip::open_or_create, "MySharedMemory", sizeof(uint64_t) *QSIZE *2);
+  // auto a_queue = new atomic_queue::AtomicQueueB<shm::Element, shm::char_alloc, shm::NIL>(65536);
+  // the_queue = static_cast<SW_Queue>(segment->find_or_construct<sw_queue_t>("MyQueue")());
+  // auto data = static_cast<uint64_t*>(segment->find_or_construct<uint64_t>("smtx_queue_data")[QSIZE]());
+  if (the_queue == nullptr) {
+    std::cout << "Error: could not create queue" << std::endl;
+    return 1;
+  }
+  the_queue->data = data;
+  if (the_queue->data == nullptr) {
+    std::cout << "Error: could not create queue data" << std::endl;
+    return 1;
+  }
+  /* Initialize the queue data structure */
+  the_queue->p_data = (uint64_t) the_queue->data;
+  the_queue->c_inx = 0;
+  the_queue->c_margin = 0;
+  the_queue->p_glb_inx = 0;
+  the_queue->c_glb_inx = 0;
+  the_queue->ptr_c_glb_inx = &(the_queue->c_glb_inx);
+  the_queue->ptr_p_glb_inx = &(the_queue->p_glb_inx);
+
+  DependenceModule depMod(0, 0);
+
+  uint64_t counter = 0;
+  // shm::shared_string v(char_alloc);
+
+  using Action = NewDepModAction;
+
+  uint32_t loop_id;
+  uint32_t v, d;
+
+  uint64_t last = 0;
+  while (true) {
+    CONSUME_2(v, d);
+
+    counter++;
+
+    Action action = static_cast<Action>(v);
+
+    switch (action) {
+    case Action::INIT: {
+      uint32_t pid;
+      loop_id = d;
+      pid = (uint32_t)CONSUME;
+
+      if (DEBUG) {
+        std::cout << last << std::endl;
+        std::cout << ((uint64_t)v << 32 | d) << std::endl;
+        std::cout << "INIT: " << loop_id << " " << pid << std::endl;
+      }
+#if ACTION
+      depMod.init(loop_id, pid);
+#endif
+      break;
+    };
+    case Action::LOAD: {
+      uint32_t instr = d;
+      uint64_t addr;
+      uint32_t bare_instr;
+      uint64_t value = 0;
+      addr = CONSUME;
+      // value = CONSUME;
+      if (DEBUG) {
+        std::cout << "LOAD: " << instr << " " << addr << " " << bare_instr
+                  << " " << value << std::endl;
+      }
+#if ACTION
+      depMod.load(instr, addr, instr);
+      // DepMod::load(instr, addr, bare_instr, value);
+#endif
+
+      break;
+    };
+    case Action::STORE: {
+      uint32_t instr = d;
+      uint32_t bare_instr;
+      uint64_t addr;
+      addr = CONSUME;
+      if (DEBUG) {
+        std::cout << "STORE: " << instr << " " << bare_instr << " " << addr
+                  << std::endl;
+      }
+#if ACTION
+      depMod.store(instr, bare_instr, addr);
+#endif
+      break;
+    };
+    case Action::ALLOC: {
+      uint64_t addr;
+      uint32_t size = d;
+      addr = CONSUME;
+      if (DEBUG) {
+        std::cout << "ALLOC: " << addr << " " << size << std::endl;
+      }
+#if ACTION
+      depMod.allocate(reinterpret_cast<void *>(addr), size);
+#endif
+      break;
+    };
+    case Action::LOOP_INVOC: {
+#if ACTION
+      depMod.loop_invoc();
+#endif
+
+      if (DEBUG) {
+        std::cout << "LOOP_INVOC" << std::endl;
+      }
+      break;
+    };
+    case Action::LOOP_ITER: {
+#if ACTION
+      depMod.loop_iter();
+#endif
+
+      if (DEBUG) {
+        std::cout << "LOOP_ITER" << std::endl;
+      }
+      break;
+    };
+    case Action::FINISHED: {
+      std::stringstream ss;
+      ss << "deplog-" << loop_id << ".txt";
+#if ACTION
+      depMod.fini(ss.str().c_str());
+#endif
+      std::cout << "Finished loop: " << loop_id << " after " << counter
+                << " events" << std::endl;
+      exit(0);
+      break;
+    };
+    case Action::FUNC_ENTRY:
+    case Action::FUNC_EXIT:
+    case Action::LOOP_ENTRY:
+    case Action::LOOP_EXIT:
+    case Action::LOOP_ITER_CTX:
+      // if (DEBUG) {
+        // std::cout << "Action: " << v << std::endl;
+      // }
+      break;
+    case Action::POINTS_TO_ARG: {
+      uint64_t addr;
+      addr = CONSUME;
+      if (DEBUG) {
+      // std::cout << "Action: " << v << " " << addr << std::endl;
+      }
+      break;
+    }
+    case Action::POINTS_TO_INST: {
+      uint64_t addr;
+      addr = CONSUME;
+      if (DEBUG) {
+      // // std::cout << "Action: " << v << std::endl;
+      }
+      break;
+    }
+    case Action::HEAP_FREE: {
+      uint64_t addr;
+      addr = CONSUME;
+      if (DEBUG) {
+      // std::cout << "Action: " << v << " " << addr << std::endl;
+      }
+      break;
+    }
+    case Action::STACK_ALLOC:
+    case Action::STACK_FREE:
+      break;
+    default:
+      std::cout << last << std::endl;
+      std::cout << "Unknown action: " << v << std::endl;
+      exit(-1);
+    };
+    last  = v;
+    // if (counter % 100000000 == 0) {
+      // std::cout << "Processed " << counter / 1000000 << "M events" << std::endl;
+    // }
+  }
+}
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/inline.h b/liberty/lib/SLAMP/SLAMPsmtxq/inline.h
new file mode 100644
index 00000000..7b16986f
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/inline.h
@@ -0,0 +1,12 @@
+#ifndef INLINE_H
+#define INLINE_H
+
+#define Weak __attribute__((weak))
+
+#ifndef NO_INLINE
+#define Inline static inline
+#else /* NO_INLINE */
+#define Inline Weak
+#endif/* NO_INLINE */
+
+#endif /* INLINE_H */
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPsmtxq/slamp_hooks.h
new file mode 100644
index 00000000..b18efd38
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/slamp_hooks.h
@@ -0,0 +1,372 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void* SLAMP_realloc_hook(void *ptr, size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue.c b/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue.c
new file mode 100644
index 00000000..33199929
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue.c
@@ -0,0 +1,103 @@
+#include <assert.h>
+#include <stdio.h>
+
+#include "sw_queue_astream.h"
+
+/*
+ * Create and initialize a queue.
+ */
+SW_Queue sq_createQueue(void)
+{
+  return sq_initQueue(sq_createQueueBlock(1));
+}
+
+/*
+ * Creates, but does not initialize a block of queues.
+ */
+SW_Queue sq_createQueueBlock(unsigned queues) {
+
+  /* Allocate the queue data structure */
+  sw_queue_t *queue = (sw_queue_t *) mmap((void *) (1UL << 32),
+                                          queues * sizeof(sw_queue_t),
+                                          PROT_WRITE | PROT_READ,
+                                          MAP_SHARED | MAP_ANONYMOUS,
+                                          -1,
+                                          (off_t) 0);
+  if(queue == (sw_queue_t *) -1) {
+    perror("sq_createQueue");
+    exit(1);
+  }
+
+  return queue;
+}
+
+/*
+ * Initialize a queue. sq_createQueue does this automatically.
+ */
+SW_Queue sq_initQueue(SW_Queue queue) {
+  
+  /* Allocate the queue */
+  queue->data = (uint64_t *) mmap(0,
+                                  sizeof(uint64_t) * QSIZE,
+                                  PROT_WRITE | PROT_READ,
+                                  MAP_SHARED | MAP_ANONYMOUS | MAP_32BIT,
+                                  -1,
+                                  (off_t) 0);
+  
+  if(queue->data == (void *) -1) {
+    perror("sq_initQueue");
+    exit(1);
+  }
+
+  /* Initialize the queue data structure */
+  queue->p_data = (uint64_t) queue->data;
+  queue->c_inx = 0;
+  queue->c_margin = 0;
+  queue->p_glb_inx = 0;
+  queue->c_glb_inx = 0;
+  queue->ptr_c_glb_inx = &(queue->c_glb_inx);
+  queue->ptr_p_glb_inx = &(queue->p_glb_inx);
+
+#ifdef INSTRUMENT
+  queue->total_produces = 0;
+  queue->total_consumes = 0;
+#endif
+
+  return queue;  
+}
+
+void sq_freeQueueBlock(SW_Queue queue, unsigned size) {
+
+  for(unsigned i = 0; i < size; ++i) {
+
+    /* This queue may never have been initialized. */
+    if(queue[i].data) {
+      
+#ifdef INSTRUMENT
+      fprintf(stderr, "Queue %p: %ld produces, %ld consumes\n",
+              (void*)queue,
+              queue->total_produces,
+              queue->total_consumes);
+#endif
+
+      if(munmap(queue[i].data, sizeof(uint64_t) * QSIZE)) {
+        perror("sq_freeQueueBlock");
+        exit(-1);
+      }
+    }
+  }
+
+  if(munmap(queue, sizeof(sw_queue_t) * size)) {
+    perror("sq_freeQueueBlock");
+    exit(-1);    
+  }
+}
+
+/*
+ * Free a queue.
+ */
+void sq_freeQueue(SW_Queue queue)
+{
+  sq_freeQueueBlock(queue, 1);
+}
+
diff --git a/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue_astream.h b/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue_astream.h
new file mode 100644
index 00000000..bf837e08
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPsmtxq/sw_queue_astream.h
@@ -0,0 +1,389 @@
+/** ***********************************************/
+/** *** SW Queue with Supporting Variable Size ****/
+/** ***********************************************/
+#ifndef SW_QUEUE_H
+#define SW_QUEUE_H
+
+#define DUALCORE
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <xmmintrin.h>
+#include <unistd.h>
+
+#include "inline.h"
+#include "bitcast.h"
+#ifndef CACHELINE_SIZE
+#define CACHELINE_SIZE 64
+/*#define CACHELINE_SIZE 64 */
+/* Cache line size of glacier, as reported by lmbench. Other tests,
+ * namely the smtx ones, vindicate this. */
+#endif /* CACHELINE_SIZE */
+
+#ifndef CHUNK_SIZE
+#ifdef DUALCORE
+#define CHUNK_SIZE (1 << 8)
+#else /* DUALCORE */
+#define CHUNK_SIZE (1 << 14)
+#endif /* DUALCORE */
+#endif /* CHUNK_SIZE */
+
+#define HIGH_CHUNKMASK ((((uint64_t) (CHUNK_SIZE - 1)) << 32))
+
+#ifndef STREAM
+#ifdef DUALCORE
+#define STREAM (false)
+#else /* DUALCORE */
+#define STREAM (true)
+#endif /* DUALCORE */
+#endif /* STREAM */
+
+#if !STREAM
+#define sq_write sq_stdWrite
+#else /* STREAM */
+#define sq_write sq_streamWrite
+#endif /* STREAM */
+
+#ifndef QMARGIN
+#define QMARGIN 4
+#endif /* QMARGIN */
+
+#ifndef QSIZE
+#define QSIZE (1 << 21)
+#endif /* QSIZE */
+
+#ifndef QPREFETCH
+#define QPREFETCH (1 << 7)
+#endif /* QPREFETCH */
+
+#define QMASK (QSIZE - 1)
+#define HIGH_QMASK (((uint64_t) QMASK) << 32 | (uint32_t) ~0)
+
+#define PAD(suffix, size) char padding ## suffix [CACHELINE_SIZE - (size)]
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef struct {
+
+  uint64_t p_data;
+  PAD(1, sizeof(uint64_t));
+
+  volatile uint32_t *ptr_c_glb_inx;
+  uint32_t p_glb_inx;
+  PAD(2, sizeof(volatile uint32_t *) + sizeof(uint32_t));
+
+  uint32_t c_margin;
+  uint32_t c_inx;
+  PAD(3, sizeof(uint32_t) * 2);
+
+  volatile uint32_t *ptr_p_glb_inx;
+  uint32_t c_glb_inx;
+  PAD(4, sizeof(volatile uint32_t *) + sizeof(uint32_t));
+
+  uint64_t *data;
+
+  uint64_t  total_produces;
+  uint64_t  total_consumes;
+
+  PAD(5, sizeof(volatile uint64_t *) + sizeof(uint64_t) * 2);
+
+} sw_queue_t, *SW_Queue;
+
+typedef void *sq_cbData;
+typedef void (*sq_callback)(sq_cbData);
+
+/* ***************************************** */
+/* ******* Detail Implementation *********** */
+/* ***************************************** */
+
+SW_Queue sq_createQueue(void);
+SW_Queue sq_createQueueBlock(unsigned queues);
+SW_Queue sq_initQueue(SW_Queue queue);
+void sq_freeQueueBlock(SW_Queue queue, unsigned size);
+void sq_freeQueue(SW_Queue q);
+
+/* ******************************************************** */
+/* ***********  Preallocate Method  *********************** */
+/* ******************************************************** */
+
+/*
+ * This method is faster on multi-processor machines as it bypasses the L2
+ * cache.
+ */
+Inline void sq_streamWrite(uint64_t *addr, uint64_t value) {
+
+  /*   __m64 mmxReg = _mm_set_pi64x((int64_t) value); */
+  /*   _mm_stream_pi((__m64 *) addr, mmxReg); */
+
+  __asm (
+         "movntiq %1, (%0)\n"
+         :
+         : "r" (addr), "r" (value)
+         );
+}
+
+/*
+ * This method is faster on multi-core machines as it exploits the common L2
+ * cache.
+ */
+Inline void sq_stdWrite(uint64_t *addr, uint64_t value) {
+  *addr = value;
+}
+
+/*
+ * Modulo subtraction
+ */
+Inline uint32_t sq_modSub(uint32_t minuend,
+                          uint32_t subtrahend,
+                          uint32_t mask) {
+  return (minuend - subtrahend) & mask;
+}
+
+Inline uint32_t sq_pInx(SW_Queue q) {
+  return (uint32_t) (q->p_data >> 32);
+}
+
+/*
+ * Flush all produce values.
+ *
+ * sfence is slow, but necessary for streaming writes. sfence MUST proceded
+ * updating p_glb_inx, otherwise there will be a race condition.
+ */
+Inline void sq_flushQueue(SW_Queue q)
+{
+#if STREAM
+  _mm_sfence();
+#endif
+
+  *q->ptr_p_glb_inx = sq_pInx(q);
+}
+
+/*
+ * Wait on the consumer.
+ *
+ * Pausing while spinning improves performance on NetBurst and improves energy
+ * efficiency.
+ */
+Inline void sq_waitConsumer(SW_Queue q, sq_callback cb, sq_cbData cbd)
+{
+#ifndef NO_CON
+  uint32_t threshold = (QMARGIN - 1) * QSIZE / QMARGIN;
+  if(sq_modSub(sq_pInx(q), *q->ptr_c_glb_inx, QMASK) > threshold) {
+
+    /* Blocking path */
+    cb(cbd);
+
+    while(sq_modSub(sq_pInx(q), *q->ptr_c_glb_inx, QMASK) > threshold) {
+      usleep(10);
+    }
+  } else {
+
+    /* Fast path */
+    sq_flushQueue(q);
+  }
+#endif /* NO_CON */
+}
+
+/*
+ * Produce a value to a queue.
+ */
+// Inline void sq_produce(SW_Queue q, uint64_t value,
+void sq_produce(SW_Queue q, uint64_t value,
+                       sq_callback cb, sq_cbData cbd) // attribute: noinline
+__attribute__((noinline))
+
+{
+#ifdef INSTRUMENT
+  q->total_produces++;
+#endif
+
+  uint64_t pDataRaw = q->p_data;
+  uint32_t pInx = sq_pInx(q);
+  uint64_t *pData = (uint64_t *) (size_t) (uint32_t) q->p_data;
+  uint64_t *ptr = pInx + pData;
+
+  sq_write(ptr, value);
+  q->p_data = (pDataRaw + (1ULL << 32)) & HIGH_QMASK;
+
+  if(!(q->p_data & HIGH_CHUNKMASK)) {
+    sq_waitConsumer(q, cb, cbd);
+  }
+}
+
+#define sq_produce(Q,V) sq_produce(Q, V, (sq_callback) sq_flushQueue, Q)
+
+/*
+ * Produce two values to a queue. Do not intermingle with sq_produce.
+ */
+// Inline void sq_produce2(SW_Queue q, uint64_t a, uint64_t b,
+void sq_produce2(SW_Queue q, uint64_t a, uint64_t b,
+                        sq_callback cb, sq_cbData cbd)
+{
+#ifdef INSTRUMENT
+  q->total_produces += 2;
+#endif
+
+  /* Otherwise, gcc couldn't constant propagate. */
+  uint64_t pDataRaw = q->p_data;
+  uint32_t pInx = sq_pInx(q);
+  uint64_t *pData = (uint64_t *) (size_t) (uint32_t) q->p_data;
+  uint64_t *ptr = pInx + pData;
+
+  sq_write(ptr + 0, a);
+  sq_write(ptr + 1, b);
+
+  q->p_data = (pDataRaw + (2ULL << 32)) & HIGH_QMASK;
+
+  if(!(q->p_data & HIGH_CHUNKMASK)) {
+    sq_waitConsumer(q, cb, cbd);
+  }
+}
+
+#define sq_produce2(Q,A,B) sq_produce2(Q, A, B, (sq_callback) sq_flushQueue, Q)
+
+
+Inline void sq_produceDouble(SW_Queue q, double value, sq_callback cb, sq_cbData cbd) {
+  uint64_t pDataRaw = q->p_data;
+  uint32_t pInx = sq_pInx(q);
+  uint64_t *pData = (uint64_t *) (size_t) (uint32_t) q->p_data;
+  uint64_t *ptr = pInx + pData;
+  uint64_t valueInt = (uint64_t)doubleToInt(value);
+  sq_write(ptr, valueInt);
+  q->p_data = (pDataRaw + (1ULL << 32)) & HIGH_QMASK;
+
+  if(!(q->p_data & HIGH_CHUNKMASK)) {
+    sq_waitConsumer(q, cb, cbd);
+  }
+}
+
+#define sq_produceDouble(Q, V) sq_produceDouble(Q, V, (sq_callback) sq_flushQueue, Q)
+
+/* Functions for Consumer */
+
+/*
+ * Makes reads globally visible
+ */
+
+Inline void sq_reverseFlush(const SW_Queue q) {
+  *q->ptr_c_glb_inx = q->c_inx;
+}
+
+/*
+ * Wait for a produce
+ */
+Inline uint32_t sq_waitAllocated(const SW_Queue q, sq_callback cb, sq_cbData cbd)
+{
+  if(*q->ptr_p_glb_inx == q->c_inx) {
+
+    /* Blocking path */
+    cb(cbd);
+    while(*q->ptr_p_glb_inx == q->c_inx) usleep(10);
+
+  } else {
+    /* Fast path */
+    sq_reverseFlush(q);
+  }
+
+  return *q->ptr_p_glb_inx;
+}
+
+/*
+ * Consume a 64-bit value from the queue.
+ */
+Inline uint64_t sq_consume(SW_Queue q, sq_callback cb, sq_cbData cbd)
+{
+#ifdef INSTRUMENT
+  q->total_consumes++;
+#endif
+
+  if(q->c_inx == q->c_margin) {
+    q->c_margin = sq_waitAllocated(q, cb, cbd);
+  }
+
+  uint64_t val = q->data[q->c_inx];
+
+  if(QPREFETCH) {
+    _mm_prefetch(q->data + q->c_inx + QPREFETCH, _MM_HINT_T0);
+  }
+
+  q->c_inx++;
+  q->c_inx &= QMASK;
+  return val;
+}
+
+#define sq_consume(Q) sq_consume(Q, (sq_callback) sq_reverseFlush, Q)
+
+
+Inline double sq_consumeDouble(SW_Queue q, sq_callback cb, sq_cbData cbd)
+{
+#ifdef INSTRUMENT
+  q->total_consumes++;
+#endif
+
+  if(q->c_inx == q->c_margin) {
+    q->c_margin = sq_waitAllocated(q, cb, cbd);
+  }
+
+  uint64_t val = q->data[q->c_inx];
+
+  if(QPREFETCH) {
+    _mm_prefetch(q->data + q->c_inx + QPREFETCH, _MM_HINT_T0);
+  }
+
+  q->c_inx++;
+  q->c_inx &= QMASK;
+  double valDouble = intToDouble((int64_t)val);
+  return valDouble;
+}
+
+#define sq_consumeDouble(Q) sq_consumeDouble(Q, (sq_callback) sq_reverseFlush, Q)
+
+Inline bool sq_canConsume(const SW_Queue q) {
+  return q->c_margin != q->c_inx || *q->ptr_p_glb_inx != q->c_inx;
+}
+
+/*
+ * Empty the queue.
+ *
+ * Races with producer methods.
+ */
+Inline void sq_emptyQueue(SW_Queue q) {
+  q->c_margin = q->c_inx = *q->ptr_p_glb_inx;
+  sq_reverseFlush(q);
+}
+
+/*
+ * Modulo arithmetic (llvmism)
+ */
+Inline bool sq_selectProducer(unsigned prevChoice,
+                              SW_Queue *queues,
+                              unsigned numQueues) {
+  (void) queues;
+
+  if( ++prevChoice >= numQueues )
+    prevChoice = 0;
+
+  return prevChoice;
+}
+
+/*
+ * Modulo arithmetic (llvmism)
+ */
+Inline bool sq_selectConsumer(unsigned prevChoice,
+                              SW_Queue *queues,
+                              unsigned numQueues) {
+
+  (void) queues;
+
+  if( ++prevChoice >= numQueues )
+    prevChoice = 0;
+
+  return prevChoice;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* SW_QUEUE_H */
diff --git a/liberty/lib/SLAMP/SLAMPstats/CMakeLists.txt b/liberty/lib/SLAMP/SLAMPstats/CMakeLists.txt
new file mode 100644
index 00000000..53db9b61
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPstats/CMakeLists.txt
@@ -0,0 +1,24 @@
+file(GLOB SRCS
+    "*.cpp"
+)
+# add CMAKE_PREFIX_PATH 
+set(CMAKE_C_COMPILER "clang")
+set(CMAKE_CXX_COMPILER "clang++")
+
+# Compilation flags
+# set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-Wl,-save-temps -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set_source_files_properties(${SRCS} PROPERTIES COMPILE_FLAGS "-flto -std=c++17 -Wno-inline -O3 -fexceptions")# -emit-llvm")
+set(PassName "slamp_hooks_stats")
+
+
+# list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+#include(HandleLLVMOptions)
+# include(AddLLVM)
+
+
+add_llvm_library(${PassName} STATIC ${SRCS})
+# target_link_libraries(${PassName} nng::nng)
+# add_llvm_library(${PassName}_shared SHARED ${SRCS})
+# set_target_properties(${PassName}_shared PROPERTIES OUTPUT_NAME ${PassName})
+# set_property(TARGET ${PassName} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+#add_llvm_library(${PassName} SHARED ${SRCS}) # This is to generate libxxx.so
diff --git a/liberty/lib/SLAMP/SLAMPstats/Stats.cpp b/liberty/lib/SLAMP/SLAMPstats/Stats.cpp
new file mode 100644
index 00000000..9c139cb1
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPstats/Stats.cpp
@@ -0,0 +1,628 @@
+#include <iostream>
+#include <fstream>
+
+#include "slamp_hooks.h"
+#include "malloc.h"
+#include "json.hpp"
+
+// context counters
+unsigned long counter_fcn_enter = 0;
+unsigned long counter_fcn_exit = 0;
+unsigned long counter_loop_enter = 0;
+unsigned long counter_loop_exit = 0;
+unsigned long counter_loop_iter = 0;
+unsigned long counter_loop_invoc_interest = 0;
+unsigned long counter_loop_iter_interest = 0;
+unsigned long counter_loop_exit_interest = 0;
+unsigned long counter_ext_fcn_enter = 0;
+unsigned long counter_ext_fcn_exit = 0;
+
+// load/store counters
+unsigned long counter_load_1 = 0;
+unsigned long counter_load_2 = 0;
+unsigned long counter_load_4 = 0;
+unsigned long counter_load_8 = 0;
+unsigned long counter_load_n = 0;
+unsigned long counter_store_1 = 0;
+unsigned long counter_store_2 = 0;
+unsigned long counter_store_4 = 0;
+unsigned long counter_store_8 = 0;
+unsigned long counter_store_n = 0;
+
+unsigned long counter_load_1_interest = 0;
+unsigned long counter_load_2_interest = 0;
+unsigned long counter_load_4_interest = 0;
+unsigned long counter_load_8_interest = 0;
+unsigned long counter_load_n_interest = 0;
+unsigned long counter_store_1_interest = 0;
+unsigned long counter_store_2_interest = 0;
+unsigned long counter_store_4_interest = 0;
+unsigned long counter_store_8_interest = 0;
+unsigned long counter_store_n_interest = 0;
+
+// memory access counters
+unsigned long counter_global = 0;
+unsigned long counter_alloca = 0;
+unsigned long counter_alloca_bytes = 0;
+unsigned long counter_stack_free = 0;
+unsigned long counter_malloc = 0;
+unsigned long counter_malloc_bytes = 0;
+unsigned long counter_memalign = 0;
+unsigned long counter_memalign_bytes = 0;
+unsigned long counter_realloc = 0;
+unsigned long counter_realloc_bytes = 0;
+unsigned long counter_free = 0;
+unsigned long counter_report_base = 0;
+
+static int nested_level = 0;
+static bool on_profiling = false;
+
+#define TURN_OFF_CUSTOM_MALLOC do {\
+  __malloc_hook = old_malloc_hook; \
+  __free_hook = old_free_hook; \
+  __realloc_hook = old_realloc_hook;\
+  __memalign_hook = old_memalign_hook; \
+} while (false);
+
+#define TURN_ON_CUSTOM_MALLOC do { \
+  __malloc_hook = SLAMP_malloc_hook; \
+  __free_hook = SLAMP_free_hook; \
+  __realloc_hook = SLAMP_realloc_hook; \
+  __memalign_hook = SLAMP_memalign_hook; \
+} while (false);
+
+static void *(*old_malloc_hook)(size_t, const void *);
+static void (*old_free_hook)(void *, const void *);
+static void *(*old_memalign_hook)(size_t, size_t, const void *);
+static void *(*old_realloc_hook)(void *, size_t, const void *);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id) {
+  // replace hooks
+  old_malloc_hook = __malloc_hook;
+  old_free_hook = __free_hook;
+  old_memalign_hook = __memalign_hook;
+  old_realloc_hook = __realloc_hook;
+
+  TURN_ON_CUSTOM_MALLOC;
+}
+
+void SLAMP_fini(const char* filename){
+  TURN_OFF_CUSTOM_MALLOC;
+  // print stats to file
+  std::ofstream stats_file;
+  stats_file.open(filename);
+
+  using json = nlohmann::json;
+  json outfile;
+
+  outfile["context"]["fcn_enter"] = counter_fcn_enter;
+  outfile["context"]["fcn_exit"] = counter_fcn_exit;
+  outfile["context"]["loop_enter"] = counter_loop_enter;
+  outfile["context"]["loop_exit"] = counter_loop_exit;
+  outfile["context"]["loop_iter"] = counter_loop_iter;
+  outfile["context"]["loop_invoc_interest"] = counter_loop_invoc_interest;
+  outfile["context"]["loop_iter_interest"] = counter_loop_iter_interest;
+  outfile["context"]["loop_exit_interest"] = counter_loop_exit_interest;
+  outfile["context"]["ext_fcn_enter"] = counter_ext_fcn_enter;
+  outfile["context"]["ext_fcn_exit"] = counter_ext_fcn_exit;
+
+  outfile["load_store"]["load_1"] = counter_load_1;
+  outfile["load_store"]["load_2"] = counter_load_2;
+  outfile["load_store"]["load_4"] = counter_load_4;
+  outfile["load_store"]["load_8"] = counter_load_8;
+  outfile["load_store"]["load_n"] = counter_load_n;
+  outfile["load_store"]["store_1"] = counter_store_1;
+  outfile["load_store"]["store_2"] = counter_store_2;
+  outfile["load_store"]["store_4"] = counter_store_4;
+  outfile["load_store"]["store_8"] = counter_store_8;
+  outfile["load_store"]["store_n"] = counter_store_n;
+
+  outfile["load_store"]["load_1_interest"] = counter_load_1_interest;
+  outfile["load_store"]["load_2_interest"] = counter_load_2_interest;
+  outfile["load_store"]["load_4_interest"] = counter_load_4_interest;
+  outfile["load_store"]["load_8_interest"] = counter_load_8_interest;
+  outfile["load_store"]["load_n_interest"] = counter_load_n_interest;
+  outfile["load_store"]["store_1_interest"] = counter_store_1_interest;
+  outfile["load_store"]["store_2_interest"] = counter_store_2_interest;
+  outfile["load_store"]["store_4_interest"] = counter_store_4_interest;
+  outfile["load_store"]["store_8_interest"] = counter_store_8_interest;
+  outfile["load_store"]["store_n_interest"] = counter_store_n_interest;
+
+  outfile["memory_access"]["global"] = counter_global;
+  outfile["memory_access"]["alloca"] = counter_alloca;
+  outfile["memory_access"]["alloca_bytes"] = counter_alloca_bytes;
+  outfile["memory_access"]["stack_free"] = counter_stack_free;
+  outfile["memory_access"]["malloc"] = counter_malloc;
+  outfile["memory_access"]["malloc_bytes"] = counter_malloc_bytes;
+  outfile["memory_access"]["memalign"] = counter_memalign;
+  outfile["memory_access"]["memalign_bytes"] = counter_memalign_bytes;
+  outfile["memory_access"]["realloc"] = counter_realloc;
+  outfile["memory_access"]["realloc_bytes"] = counter_realloc_bytes;
+  outfile["memory_access"]["free"] = counter_free;
+  outfile["memory_access"]["report_base"] = counter_report_base;
+
+  stats_file << outfile.dump(2);
+  stats_file.close();
+}
+
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size){
+  counter_global++;
+}
+void SLAMP_allocated(uint64_t addr){}
+
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env){}
+
+void SLAMP_enter_fcn(uint32_t id){
+  counter_fcn_enter++;
+}
+
+void SLAMP_exit_fcn(uint32_t id){
+  counter_fcn_exit++;
+}
+
+void SLAMP_enter_loop(uint32_t id){
+  counter_loop_enter++;
+}
+
+void SLAMP_exit_loop(uint32_t id){
+  counter_loop_exit++;
+}
+void SLAMP_loop_iter_ctx(uint32_t id){
+  counter_loop_iter++;
+}
+
+void SLAMP_loop_invocation(){
+
+  nested_level++;
+  on_profiling = true;
+
+  counter_loop_invoc_interest++;
+
+  // if (counter_invoc % 1 == 0) {
+    // on_profiling= true;
+  // }
+}
+void SLAMP_loop_iteration(){
+  counter_loop_iter_interest++;
+}
+void SLAMP_loop_exit(){
+  counter_loop_exit_interest++;
+  nested_level--;
+  if (nested_level < 0) {
+    // huge problem
+    std::cerr << "Error: nested_level < 0" << std::endl;
+    exit(-1);
+  }
+  if (nested_level == 0) {
+    on_profiling = false;
+  }
+}
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr){
+  counter_report_base++;
+}
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr){
+  counter_report_base++;
+}
+
+void SLAMP_callback_stack_alloca(uint64_t array_sz, uint64_t type_sz, uint32_t instr, uint64_t addr){
+  counter_alloca++;
+  counter_alloca_bytes += array_sz * type_sz;
+}
+
+void SLAMP_callback_stack_free(){
+  counter_stack_free++;
+}
+
+void SLAMP_ext_push(const uint32_t instr){
+  counter_ext_fcn_enter++;
+}
+void SLAMP_ext_pop(){
+  counter_ext_fcn_exit++;
+}
+
+void SLAMP_push(const uint32_t instr){}
+void SLAMP_pop(){}
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_1++;
+  counter_load_1_interest++;
+}
+
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_2++;
+  counter_load_2_interest++;
+}
+
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_4++;
+  counter_load_4_interest++;
+}
+
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_8++;
+  counter_load_8_interest++;
+}
+
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n){
+  counter_load_n++;
+  counter_load_n_interest++;
+}
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_1++;
+  if (on_profiling) {
+    counter_load_1_interest++;
+  }
+}
+
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_2++;
+  if (on_profiling) {
+    counter_load_2_interest++;
+  }
+}
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_4++;
+  if (on_profiling) {
+    counter_load_4_interest++;
+  }
+}
+
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value){
+  counter_load_8++;
+  if (on_profiling) {
+    counter_load_8_interest++;
+  }
+}
+
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n){
+  counter_load_n++;
+  if (on_profiling) {
+    counter_load_n_interest++;
+  }
+}
+
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr){
+  counter_store_1++;
+  counter_store_1_interest++;
+}
+void SLAMP_store2(uint32_t instr, const uint64_t addr){
+  counter_store_2++;
+  counter_store_2_interest++;
+}
+void SLAMP_store4(uint32_t instr, const uint64_t addr){
+  counter_store_4++;
+  counter_store_4_interest++;
+}
+void SLAMP_store8(uint32_t instr, const uint64_t addr){
+  counter_store_8++;
+  counter_store_8_interest++;
+}
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n){
+  counter_store_n++;
+  counter_store_n_interest++;
+}
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst){
+  counter_store_1++;
+  if (on_profiling) {
+    counter_store_1_interest++;
+  }
+}
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst){
+  counter_store_2++;
+  if (on_profiling) {
+    counter_store_2_interest++;
+  }
+}
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst){
+  counter_store_4++;
+  if (on_profiling) {
+    counter_store_4_interest++;
+  }
+}
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst){
+  counter_store_8++;
+  if (on_profiling) {
+    counter_store_8_interest++;
+  }
+}
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n){
+  counter_store_n++;
+  if (on_profiling) {
+    counter_store_n_interest++;
+  }
+}
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller){
+  void *result;
+  TURN_OFF_CUSTOM_MALLOC;
+  result = malloc(size);
+  TURN_ON_CUSTOM_MALLOC;
+  counter_malloc++;
+  counter_malloc_bytes += size;
+  return result;
+}
+static void SLAMP_free_hook(void *ptr, const void *caller){
+  TURN_OFF_CUSTOM_MALLOC;
+  free(ptr);
+  TURN_ON_CUSTOM_MALLOC;
+  counter_free++;
+}
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller){
+  void *result;
+  TURN_OFF_CUSTOM_MALLOC;
+  result = memalign(alignment, size);
+  TURN_ON_CUSTOM_MALLOC;
+  counter_memalign++;
+  counter_memalign_bytes += size;
+
+  return result;
+}
+
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller){
+  TURN_OFF_CUSTOM_MALLOC;
+  void* new_ptr = realloc(ptr, size);
+  TURN_ON_CUSTOM_MALLOC;
+  counter_realloc++;
+  counter_realloc_bytes += size;
+  return new_ptr;
+}
+
+void* SLAMP_malloc(size_t size, uint32_t instr, size_t alignment){}
+void* SLAMP_calloc(size_t nelem, size_t elsize){}
+void* SLAMP_realloc(void* ptr, size_t size){}
+void* SLAMP__Znam(size_t size){}
+void* SLAMP__Znwm(size_t size){}
+
+
+
+char* SLAMP_strdup(const char *s1){}
+char* SLAMP___strdup(const char *s1){}
+void  SLAMP_free(void* ptr){}
+void  SLAMP_cfree(void* ptr){}
+void  SLAMP__ZdlPv(void* ptr){}
+void  SLAMP__ZdaPv(void* ptr){}
+int   SLAMP_brk(void *end_data_segment){}
+void* SLAMP_sbrk(intptr_t increment){}
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes){}
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes){}
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len){}
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len){}
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr){}
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr){}
+
+/* String functions */
+size_t SLAMP_strlen(const char *str){}
+char* SLAMP_strchr(char *s, int c){}
+char* SLAMP_strrchr(char *s, int c){}
+int SLAMP_strcmp(const char *s1, const char *s2){}
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n){}
+char* SLAMP_strcpy(char *dest, const char *src){}
+char* SLAMP_strncpy(char *dest, const char *src, size_t n){}
+char* SLAMP_strcat(char *s1, const char *s2){}
+char* SLAMP_strncat(char *s1, const char *s2, size_t n){}
+char* SLAMP_strstr(char *s1, char *s2){}
+size_t SLAMP_strspn(const char *s1, const char *s2){}
+size_t SLAMP_strcspn(const char *s1, const char *s2){}
+char* SLAMP_strtok(char *s, const char *delim){}
+double SLAMP_strtod(const char *nptr, char **endptr){}
+long int SLAMP_strtol(const char *nptr, char **endptr, int base){}
+char* SLAMP_strpbrk(char *s1, char *s2){}
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n){}
+void *SLAMP_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n){}
+void *SLAMP_memmove (void *dest, const void *src, size_t n){}
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n){}
+void* SLAMP_memchr(void* ptr, int value, size_t num){}
+void* SLAMP___rawmemchr(void* ptr, int value){}
+
+void  SLAMP_bzero(void *s, size_t n){}
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n){}
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count){}
+int     SLAMP_open(const char *pathname, int flags, mode_t mode){}
+int     SLAMP_close(int fd){}
+ssize_t SLAMP_write(int fd, const void *buf, size_t count){}
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence){}
+
+FILE *  SLAMP_fopen(const char *path, const char *mode){}
+FILE *  SLAMP_fopen64(const char *path, const char *mode){}
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream){}
+int     SLAMP_fflush(FILE *stream){}
+int     SLAMP_fclose(FILE *stream){}
+int     SLAMP_ferror(FILE *stream){}
+int     SLAMP_feof(FILE *stream){}
+long    SLAMP_ftell(FILE *stream){}
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream){}
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream){}
+int     SLAMP_fseek(FILE *stream, long offset, int whence){}
+void    SLAMP_rewind(FILE *stream){}
+
+int     SLAMP_fgetc(FILE *stream){}
+int     SLAMP_fputc(int c, FILE *stream){}
+char *  SLAMP_fgets(char *s, int n, FILE *stream){}
+int     SLAMP_fputs(const char *s, FILE *stream){}
+
+int     SLAMP_ungetc(int c, FILE *stream){}
+int     SLAMP_putchar(int c){}
+int     SLAMP_getchar(void){}
+
+int     SLAMP_fileno(FILE *stream){}
+char *  SLAMP_gets(char *s){}
+int     SLAMP_puts(const char *s){}
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout){}
+int     SLAMP_remove(const char *path){}
+
+void    SLAMP_setbuf(FILE * stream, char * buf){}
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size){}
+char * SLAMP_tmpnam(char *s){}
+FILE* SLAMP_tmpfile(void){}
+char *  SLAMP_ttyname(int fildes){}
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode){}
+void    SLAMP_clearerr(FILE *stream){}
+
+int SLAMP_truncate(const char *path, off_t length){}
+int SLAMP_ftruncate(int fildes, off_t length){}
+
+int SLAMP_dup(int oldfd){}
+int SLAMP_dup2(int oldfd, int newfd){}
+int SLAMP_pipe(int filedes[2]){}
+
+int SLAMP_chmod(const char *path, mode_t mode){}
+int SLAMP_fchmod(int fildes, mode_t mode){}
+int SLAMP_fchown(int fd, uid_t owner, gid_t group){}
+int SLAMP_access(const char *pathname, int mode){}
+long SLAMP_pathconf(char *path, int name){}
+int SLAMP_mkdir(const char *pathname, mode_t mode){}
+int SLAMP_rmdir(const char *pathname){}
+mode_t SLAMP_umask(mode_t mask){}
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock){}
+
+DIR* SLAMP_opendir(const char* name){}
+struct dirent* SLAMP_readdir(DIR *dirp){}
+struct dirent64* SLAMP_readdir64(DIR *dirp){}
+int SLAMP_closedir(DIR* dirp){}
+
+/* Printf */
+int SLAMP_printf(const char *format, ...){}
+int SLAMP_fprintf(FILE *stream, const char *format, ...){}
+int SLAMP_sprintf(char *str, const char *format, ...){}
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...){}
+
+int SLAMP_vprintf(const char *format, va_list ap){}
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vsprintf(char *str, const char *format, va_list ap){}
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap){}
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... ){}
+int SLAMP_scanf(const char *format, ... ){}
+int SLAMP_sscanf(const char *s, const char *format, ... ){}
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... ){}
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap){}
+int SLAMP_vscanf(const char *format, va_list ap){}
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap){}
+
+/* Time */
+time_t SLAMP_time(time_t *t){}
+struct tm *SLAMP_localtime(const time_t *timer){}
+struct lconv* SLAMP_localeconv(){}
+struct tm *SLAMP_gmtime(const time_t *timer){}
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz){}
+
+/* Math */
+double SLAMP_ldexp(double x, int exp){}
+float  SLAMP_ldexpf(float x, int exp){}
+long double SLAMP_ldexpl(long double x, int exp){}
+double SLAMP_log10(double x){}
+float  SLAMP_log10f(float x){}
+long double SLAMP_log10l(long double x){}
+double SLAMP_log(double x){}
+float SLAMP_logf(float x){}
+long double SLAMP_logl(long double x){}
+
+double SLAMP_exp(double x){}
+float SLAMP_expf(float x){}
+long double SLAMP_expl(long double x){}
+
+double SLAMP_cos(double x){}
+float SLAMP_cosf(float x){}
+long double SLAMP_cosl(long double x){}
+double SLAMP_sin(double x){}
+double SLAMP_tan(double x){}
+float SLAMP_sinf(float x){}
+long double SLAMP_sinl(long double x){}
+
+double SLAMP_atan(double x){}
+float SLAMP_atanf(float x){}
+long double SLAMP_atanl(long double x){}
+
+double SLAMP_floor(double x){}
+float SLAMP_floorf(float x){}
+long double SLAMP_floorl(long double x){}
+double SLAMP_ceil(double x){}
+float SLAMP_ceilf(float x){}
+long double SLAMP_ceill(long double x){}
+
+double SLAMP_atan2(double y, double x){}
+float SLAMP_atan2f(float y, float x){}
+long double SLAMP_atan2l(long double y, long double x){}
+
+double SLAMP_sqrt(double x){}
+float SLAMP_sqrtf(float x){}
+long double SLAMP_sqrtl(long double x){}
+
+double SLAMP_pow(double x, double y){}
+float SLAMP_powf(float x, float y){}
+long double SLAMP_powl(long double x, long double y){}
+
+double SLAMP_fabs(double x){}
+float SLAMP_fabsf(float x){}
+long double SLAMP_fabsl(long double x){}
+
+double SLAMP_modf(double x, double *iptr){}
+float SLAMP_modff(float x, float *iptr){}
+long double SLAMP_modfl(long double x, long double *iptr){}
+
+double SLAMP_fmod(double x, double y){}
+
+double SLAMP_frexp(double num, int *exp){}
+float SLAMP_frexpf(float num, int *exp){}
+long double SLAMP_frexpl(long double num, int *exp){}
+
+int SLAMP_isnan(){}
+
+/* MISC */
+char *SLAMP_getenv(const char *name){}
+int SLAMP_putenv(char* string){}
+char *SLAMP_getcwd(char *buf, size_t size){}
+char* SLAMP_strerror(int errnum){}
+void SLAMP_exit(int status){}
+void SLAMP__exit(int status){}
+int  SLAMP_link(const char *oldpath, const char *newpath){}
+int  SLAMP_unlink(const char *pathname){}
+int  SLAMP_isatty(int desc){}
+int SLAMP_setuid(uid_t uid){}
+uid_t SLAMP_getuid(void){}
+uid_t SLAMP_geteuid(void){}
+int SLAMP_setgid(gid_t gid){}
+gid_t SLAMP_getgid(void){}
+gid_t SLAMP_getegid(void){}
+pid_t SLAMP_getpid(void){}
+int SLAMP_chdir(const char *path){}
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */){}
+int SLAMP_execv(const char *path, char *const argv[]){}
+int SLAMP_execvp(const char *file, char *const argv[]){}
+int SLAMP_kill(pid_t pid, int sig){}
+pid_t SLAMP_fork(void){}
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler){}
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options){}
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)){}
+int SLAMP_ioctl(int d, int request, ...){}
+unsigned int SLAMP_sleep(unsigned int seconds){}
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf){}
+char* SLAMP_nl_langinfo(nl_item item){}
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function){}
+const unsigned short int **SLAMP___ctype_b_loc(void){}
+int SLAMP__IO_getc(_IO_FILE * __fp){}
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp){}
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf){}
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf){}
diff --git a/liberty/lib/SLAMP/SLAMPstats/json.hpp b/liberty/lib/SLAMP/SLAMPstats/json.hpp
new file mode 100644
index 00000000..cb27e058
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPstats/json.hpp
@@ -0,0 +1,22091 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++
+|  |  |__   |  |  | | | |  version 3.10.5
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2022 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file doc/README.md.                                                      *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3
+#define NLOHMANN_JSON_VERSION_MINOR 10
+#define NLOHMANN_JSON_VERSION_PATCH 5
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <numeric> // accumulate
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+
+
+#include <type_traits>
+#include <utility>
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+#include <exception> // exception
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+
+#include <string>
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#include <utility> // declval, pair
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ *
+ * To the extent possible under law, the author(s) have dedicated all
+ * copyright and related and neighboring rights to this software to
+ * the public domain worldwide. This software is distributed without
+ * any warranty.
+ *
+ * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+} // namespace detail
+}  // namespace nlohmann
+
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+namespace nlohmann
+{
+namespace detail
+{
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+}  // namespace detail
+}  // namespace nlohmann
+
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used c++ version this is skipped
+#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #endif
+
+        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
+        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__clang_major__) && __clang_major__ < 7
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1940
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow to access some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows to call any std function as if (e.g. with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+inline void replace_substring(std::string& s, const std::string& f,
+                              const std::string& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find first occurrence of f
+            pos != std::string::npos;         // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+inline std::string escape(std::string s)
+{
+    replace_substring(s, "~", "~0");
+    replace_substring(s, "/", "~1");
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+static void unescape(std::string& s)
+{
+    replace_substring(s, "~1", "/");
+    replace_substring(s, "~0", "~");
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+#include <cstddef> // size_t
+
+namespace nlohmann
+{
+namespace detail
+{
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType& leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = &leaf_element; current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                     [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + detail::escape(b);
+        }) + ") ";
+#else
+        static_cast<void>(leaf_element);
+        return "";
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonType>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        position_string(pos) + ": " + exception::diagnostics(context) + what_arg;
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonType>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
+                        ": " + exception::diagnostics(context) + what_arg;
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return " at line " + std::to_string(pos.lines_read + 1) +
+               ", column " + std::to_string(pos.chars_read_current_line);
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonType>
+    static invalid_iterator create(int id_, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonType>
+    static type_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("type_error", id_) + exception::diagnostics(context) + what_arg;
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonType>
+    static out_of_range create(int id_, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("out_of_range", id_) + exception::diagnostics(context) + what_arg;
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonType>
+    static other_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
+    {
+        std::string w = exception::name("other_error", id_) + exception::diagnostics(context) + what_arg;
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template<typename T>
+constexpr T static_const<T>::value; // NOLINT(readability-redundant-declaration)
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// dispatching helper struct
+template <class T> struct identity_tag {};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#include <tuple> // tuple
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/meta/call_std/begin.hpp>
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+} // namespace nlohmann
+
+// #include <nlohmann/detail/meta/call_std/end.hpp>
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+/// a class to store JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>>
+class basic_json;
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename BasicJsonType>
+class json_pointer;
+
+/*!
+@brief default specialization
+@sa https://json.nlohmann.me/api/json/
+*/
+using json = basic_json<>;
+
+/// @brief a minimal map-like container that preserves insertion order
+/// @sa https://json.nlohmann.me/api/ordered_map/
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/// @brief specialization that maintains the insertion order of object keys
+/// @sa https://json.nlohmann.me/api/ordered_json/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+}  // namespace nlohmann
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+namespace nlohmann
+{
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B1> struct conjunction<B1> : B1 { };
+template<class B1, class... Bn>
+struct conjunction<B1, Bn...>
+: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to using it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    static constexpr auto value =
+        is_constructible<ConstructibleStringType,
+        typename BasicJsonType::string_t>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+        is_complete_type <
+        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+namespace nlohmann::detail
+{
+namespace std_fs = std::experimental::filesystem;
+} // namespace nlohmann::detail
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem>
+namespace nlohmann::detail
+{
+namespace std_fs = std::filesystem;
+} // namespace nlohmann::detail
+#endif
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
+    }
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename ConstructibleStringType,
+    enable_if_t <
+        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
+        !std::is_same<typename BasicJsonType::string_t,
+                      ConstructibleStringType>::value,
+        int > = 0 >
+void from_json(const BasicJsonType& j, ConstructibleStringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                          priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
+    }
+    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
+} // namespace
+} // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type * ;
+    using reference = value_type & ;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor;
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    const string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value(IteratorType it) noexcept
+        : anchor(std::move(it))
+    {}
+
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_value& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::reference container;
+
+  public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(cont) {}
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.end());
+    }
+};
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+} // namespace std
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+namespace nlohmann::detail
+{
+namespace std_fs = std::experimental::filesystem;
+} // namespace nlohmann::detail
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem>
+namespace nlohmann::detail
+{
+namespace std_fs = std::filesystem;
+} // namespace nlohmann::detail
+#endif
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::boolean;
+        j.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::string;
+        j.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::string;
+        j.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::string;
+        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::binary;
+        j.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::binary;
+        j.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::number_float;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::number_unsigned;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::number_integer;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::array;
+        j.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::array;
+        j.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::array;
+        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_value.array->push_back(x);
+            j.set_parent(j.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::object;
+        j.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::object;
+        j.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_value.destroy(j.m_type);
+        j.m_type = value_t::object;
+        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    j = p.string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value; // NOLINT(misc-definitions-in-headers)
+} // namespace
+} // namespace nlohmann
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+namespace nlohmann
+{
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {}
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename std::char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = std::char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return std::char_traits<char_type>::eof();
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input apdater to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+} // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+            }
+            else
+            {
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, &root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::move(value));
+            return {true, &(ref_stack.back()->m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+}  // namespace detail
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case std::char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case std::char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (format == input_format_t::ubjson)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(),
+                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value"), BasicJsonType()));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string"), BasicJsonType()));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary"), BasicJsonType()));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data()), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != static_cast<std::size_t>(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != static_cast<std::size_t>(-1))
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            default:
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string"), BasicJsonType()));
+        }
+    }
+
+    /*!
+    @param[out] result  determined size
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result)
+    {
+        switch (get_ignore_noop())
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
+    {
+        result.first = string_t::npos; // size
+        result.second = 0; // type
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size"), BasicJsonType()));
+            }
+
+            return get_ubjson_size_value(result.first);
+        }
+
+        if (current == '#')
+        {
+            return get_ubjson_size_value(result.first);
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case std::char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format_t::ubjson, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char"), BasicJsonType()));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
+            }
+        }
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        auto res = get_ubjson_size_value(size);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `std::char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec{};
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != InputIsLittleEndian)
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), BasicJsonType()));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return error_msg + " " + context + ": " + detail;
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), BasicJsonType()));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'", BasicJsonType()));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), BasicJsonType()));
+                    }
+
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::end_of_input:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), BasicJsonType()));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), BasicJsonType()));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            if (get_token() == token_type::value_separator)
+            {
+                // parse key
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                {
+                    return false;
+                }
+
+                // parse separator (:)
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
+                }
+
+                // parse values
+                get_token();
+                continue;
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), BasicJsonType()));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += "while parsing " + context + " ";
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
+                         m_lexer.get_token_string() + "'";
+        }
+        else
+        {
+            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator++(int) noexcept // NOLINT(readability-const-return-type)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator--(int) noexcept // NOLINT(readability-const-return-type)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+
+  public:
+
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator++(int) // NOLINT(readability-const-return-type)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator--(int) // NOLINT(readability-const-return-type)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", *m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", *m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", *m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator const operator++(int) // NOLINT(readability-const-return-type)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator const operator--(int) // NOLINT(readability-const-return-type)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_pointer.hpp>
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename BasicJsonType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+  public:
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const std::string& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    std::string to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               std::string{},
+                               [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + detail::escape(b);
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    operator std::string() const
+    {
+        return to_string();
+    }
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::string token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::string token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const std::string& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const std::string& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(std::string&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    static typename BasicJsonType::size_type array_index(const std::string& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, "array index '" + s + "' must not begin with '0'", BasicJsonType()));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number", BasicJsonType()));
+        }
+
+        std::size_t processed_chars = 0;
+        unsigned long long res = 0;  // NOLINT(runtime/int)
+        JSON_TRY
+        {
+            res = std::stoull(s, &processed_chars);
+        }
+        JSON_CATCH(std::out_of_range&)
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
+        }
+
+        // check if the string was completely read
+        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type", BasicJsonType())); // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range", *ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, "array index '-' (" + std::to_string(ptr->m_value.array->size()) + ") is out of range", *ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range", *ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'", BasicJsonType()));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == std::string::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = (slash == std::string::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", BasicJsonType()));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_value.object)
+                    {
+                        flatten(reference_string + "/" + detail::escape(element.first), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", element.second));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief compares two JSON pointers for equality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is equal to @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator==(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return lhs.reference_tokens == rhs.reference_tokens;
+    }
+
+    /*!
+    @brief compares two JSON pointers for inequality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is not equal @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator!=(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /// the reference tokens
+    std::vector<std::string> reference_tokens;
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_ref.hpp>
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        std::copy(s, s + length, std::back_inserter(v));
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_value.number_integer;
+                    if (j.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_value.binary->has_subtype())
+                {
+                    if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
+                    }
+                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
+                    }
+                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
+                    }
+                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC8 // ext 16
+                                               : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC9 // ext 32
+                                               : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                        j.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")", j));
+            static_cast<void>(j);
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double, true>(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(j.m_value.number_unsigned));
+        }
+        else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(j.m_value.number_unsigned));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64", j));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n));
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @tparam NumberType the type of the number
+    @tparam OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool OutputIsLittleEndian = false>
+    void write_number(const NumberType n)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <sstream> // stringstream
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+} // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            std::stringstream ss;
+                            ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (byte | 0);
+                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str(), BasicJsonType()));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    std::stringstream ss;
+                    ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (static_cast<std::uint8_t>(s.back()) | 0);
+                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str(), BasicJsonType()));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward,
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < 400);
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+
+
+#include <functional> // less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, t);
+        return {--this->end(), true};
+    }
+
+    T& operator[](const Key& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    const T& operator[](const Key& key) const
+    {
+        return at(key);
+    }
+
+    T& at(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == value.first)
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+            std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+};
+
+}  // namespace nlohmann
+
+
+#if defined(JSON_HAS_CPP_17)
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+    friend ::nlohmann::json_pointer<basic_json>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<basic_json>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2022 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#ifdef __cplusplus
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // Use transparent comparator if possible, combined with perfect forwarding
+    // on find() and count() calls prevents unnecessary string construction.
+    using object_comparator_t = std::less<>;
+#else
+    using object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.10.5", basic_json())); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (t == value_t::array || t == value_t::object)
+            {
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item get destructed
+                    // since it doesn't have any children
+                }
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                case value_t::null:
+                case value_t::boolean:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
+        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
+        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
+        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != static_cast<std::size_t>(-1))
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_type(v), m_value(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_value.object->emplace(
+                    std::move(*((*element.m_value.array)[0].m_value.string)),
+                    std::move((*element.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val)
+        : m_type(value_t::array)
+    {
+        m_value.array = create<array_t>(cnt, val);
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", basic_json()));
+        }
+
+        // copy type from first iterator
+        m_type = first.m_object->m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", *first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object = create<object_t>(first.m_it.object_iterator,
+                                                  last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *first.m_object->m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value = other.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *other.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // check that passed value is valid
+        other.assert_invariant(false);
+
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_type, other.m_type);
+        swap(m_value, other.m_value);
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+        m_value.destroy(m_type);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), *this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_value.object->at(key));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_value.array->size();
+                const auto old_capacity = m_value.array->capacity();
+#endif
+                m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return set_parent(m_value.object->operator[](key));
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    reference operator[](T* key)
+    {
+        // implicitly convert null to object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return set_parent(m_value.object->operator[](key));
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    const_reference operator[](T* key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    /// using std::is_convertible in a std::enable_if will fail when using explicit conversions
+    template < class ValueType, typename std::enable_if <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    /// overload for a default value of type const char*
+    string_t value(const typename object_t::key_type& key, const char* default_value) const
+    {
+        return value(key, string_t(default_value));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template<class ValueType, typename std::enable_if<
+                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    /// overload for a default value of type const char*
+    JSON_HEDLEY_NON_NULL(3)
+    string_t value(const json_pointer& ptr, const char* default_value) const
+    {
+        return value(ptr, string_t(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", *this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->erase(key);
+        }
+
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
+            }
+
+            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @}
+
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<typename KeyT>
+    iterator find(KeyT&& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<typename KeyT>
+    const_iterator find(KeyT&& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<typename KeyT>
+    size_type count(KeyT&& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template < typename KeyT, typename std::enable_if <
+                   !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
+    bool contains(KeyT && key) const
+    {
+        return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        const auto old_capacity = m_value.array->capacity();
+        m_value.array->push_back(std::move(val));
+        set_parent(m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        const auto old_capacity = m_value.array->capacity();
+        m_value.array->push_back(val);
+        set_parent(m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to object
+        auto res = m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), *this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        const auto old_capacity = m_value.array->capacity();
+        m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), *this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
+        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", *this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", *this));
+        }
+
+        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), *this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(first.m_object->type_name()), *first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_value.object->find(it.key());
+                if (it2 != m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            std::swap(*(m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            std::swap(*(m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            std::swap(*(m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
+        }
+    }
+
+    /// @}
+
+  public:
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return *lhs.m_value.array == *rhs.m_value.array;
+
+                case value_t::object:
+                    return *lhs.m_value.object == *rhs.m_value.object;
+
+                case value_t::null:
+                    return true;
+
+                case value_t::string:
+                    return *lhs.m_value.string == *rhs.m_value.string;
+
+                case value_t::boolean:
+                    return lhs.m_value.boolean == rhs.m_value.boolean;
+
+                case value_t::number_integer:
+                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+
+                case value_t::number_unsigned:
+                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+
+                case value_t::number_float:
+                    return lhs.m_value.number_float == rhs.m_value.number_float;
+
+                case value_t::binary:
+                    return *lhs.m_value.binary == *rhs.m_value.binary;
+
+                case value_t::discarded:
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+
+        return false;
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    // note parentheses are necessary, see
+                    // https://github.com/nlohmann/json/issues/1530
+                    return (*lhs.m_value.array) < (*rhs.m_value.array);
+
+                case value_t::object:
+                    return (*lhs.m_value.object) < (*rhs.m_value.object);
+
+                case value_t::null:
+                    return false;
+
+                case value_t::string:
+                    return (*lhs.m_value.string) < (*rhs.m_value.string);
+
+                case value_t::boolean:
+                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
+
+                case value_t::number_integer:
+                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
+
+                case value_t::number_unsigned:
+                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
+
+                case value_t::number_float:
+                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
+
+                case value_t::binary:
+                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);
+
+                case value_t::discarded:
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            default:
+                return "number";
+        }
+    }
+
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        // make a working copy to apply the patch to
+        basic_json result = *this;
+
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result[ptr];
+
+            switch (parent.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::array_index(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, &result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", *this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::array_index(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", val));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", val));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", path + "/" + std::to_string(i)}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", path + "/-"},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = path + "/" + detail::escape(it.key());
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = path + "/" + detail::escape(it.key());
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+} // namespace nlohmann
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(nlohmann::detail::value_t lhs,
+                    nlohmann::detail::value_t rhs) const noexcept
+    {
+        return nlohmann::detail::operator<(lhs, rhs);
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+} // namespace std
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_CATCH
+#undef JSON_THROW
+#undef JSON_TRY
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef JSON_HAS_CPP_11
+#undef JSON_HAS_CPP_14
+#undef JSON_HAS_CPP_17
+#undef JSON_HAS_CPP_20
+#undef JSON_HAS_FILESYSTEM
+#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/liberty/lib/SLAMP/SLAMPstats/slamp_hooks.h b/liberty/lib/SLAMP/SLAMPstats/slamp_hooks.h
new file mode 100644
index 00000000..12823d63
--- /dev/null
+++ b/liberty/lib/SLAMP/SLAMPstats/slamp_hooks.h
@@ -0,0 +1,373 @@
+#ifndef SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+#define SLAMPLIB_HOOKS_SLAMP_HOOKS_H
+
+// FIXME: inline tweak actually make things worse in sequential and better with
+// 16x, so turn it on at all time before understanding why
+#define ATTRIBUTE(x) __attribute__((x))
+// #ifdef ITO_ENABLE
+// // #define ATTRIBUTE(x) 
+// #define ATTRIBUTE(x) __attribute__((x))
+// #else
+// #define ATTRIBUTE(x)
+// #endif
+
+
+#include <bits/stdint-uintn.h>
+#include <clocale>
+#include <dirent.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/times.h>
+#include <sys/time.h>
+#include <utime.h>
+#include <string.h>
+#include <termios.h>
+#include <limits.h>
+#include <wait.h>
+#include <langinfo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SLAMP_dbggv(int id);
+void SLAMP_dbggvstr(char* str);
+
+// SLAMP measure functions
+void SLAMP_measure_init();
+void SLAMP_measure_fini();
+void SLAMP_measure_load(uint32_t id, uint64_t size);
+void SLAMP_measure_store(uint32_t id, uint64_t size);
+static void* SLAMP_measure_malloc_hook(size_t size, const void *caller);
+static void SLAMP_measure_free_hook(void *ptr, const void *caller);
+
+void SLAMP_init(uint32_t fn_id, uint32_t loop_id);
+void SLAMP_fini(const char* filename);
+
+void SLAMP_allocated(uint64_t addr);
+void SLAMP_init_global_vars(const char *name, uint64_t addr, size_t size);
+void SLAMP_main_entry(uint32_t argc, char** argv, char** env);
+
+void SLAMP_enter_fcn(uint32_t id);
+void SLAMP_exit_fcn(uint32_t id);
+void SLAMP_enter_loop(uint32_t id);
+void SLAMP_exit_loop(uint32_t id);
+void SLAMP_loop_iter_ctx(uint32_t id);
+void SLAMP_loop_invocation();
+void SLAMP_loop_iteration();
+void SLAMP_loop_exit();
+
+void SLAMP_report_base_pointer_arg(uint32_t, uint32_t, void *ptr);
+void SLAMP_report_base_pointer_inst(uint32_t, void *ptr);
+void SLAMP_callback_stack_alloca(uint64_t, uint64_t, uint32_t, uint64_t);
+void SLAMP_callback_stack_free(void);
+
+void SLAMP_ext_push(const uint32_t instr);
+void SLAMP_ext_pop();
+
+void SLAMP_push(const uint32_t instr);
+void SLAMP_pop();
+
+void SLAMP_load1(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn(uint32_t instr, const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_load1_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load2_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load4_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_load8_ext(const uint64_t addr, const uint32_t bare_instr, uint64_t value) ATTRIBUTE(always_inline);
+void SLAMP_loadn_ext(const uint64_t addr, const uint32_t bare_instr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store2(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store4(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_store8(uint32_t instr, const uint64_t addr) ATTRIBUTE(always_inline);
+void SLAMP_storen(uint32_t instr, const uint64_t addr, size_t n) ATTRIBUTE(always_inline);;
+
+void SLAMP_store1_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store2_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store4_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_store8_ext(const uint64_t addr, const uint32_t bare_inst) ATTRIBUTE(always_inline);
+void SLAMP_storen_ext(const uint64_t addr, const uint32_t bare_inst, size_t n) ATTRIBUTE(always_inline);;
+
+/* wrappers */
+static void* SLAMP_malloc_hook(size_t size, const void *caller);
+static void SLAMP_free_hook(void *ptr, const void *caller);
+static void* SLAMP_memalign_hook(size_t alignment, size_t size, const void *caller);
+static void* SLAMP_realloc_hook(void* ptr, size_t size, const void *caller);
+
+void* SLAMP_malloc(size_t size, uint32_t instr=0, size_t alignment=16);
+
+void* SLAMP_calloc(size_t nelem, size_t elsize);
+void* SLAMP_realloc(void* ptr, size_t size);
+void* SLAMP__Znam(size_t size);
+void* SLAMP__Znwm(size_t size);
+
+char* SLAMP_strdup(const char *s1);
+char* SLAMP___strdup(const char *s1);
+void  SLAMP_free(void* ptr);
+void  SLAMP_cfree(void* ptr);
+void  SLAMP__ZdlPv(void* ptr);
+void  SLAMP__ZdaPv(void* ptr);
+int   SLAMP_brk(void *end_data_segment);
+void* SLAMP_sbrk(intptr_t increment);
+
+/* llvm memory intrinsics */
+void SLAMP_llvm_memcpy_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memcpy_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i32(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint32_t sizeBytes);
+void SLAMP_llvm_memmove_p0i8_p0i8_i64(const uint8_t* dstAddr, const uint8_t* srcAddr, const uint64_t sizeBytes);
+void SLAMP_llvm_memset_p0i8_i32(const uint8_t* dstAddr, const uint32_t len);
+void SLAMP_llvm_memset_p0i8_i64(const uint8_t* dstAddr, const uint64_t len);
+
+// void SLAMP_llvm_lifetime_start_p0i8(uint64_t size, uint8_t* ptr);
+// void SLAMP_llvm_lifetime_end_p0i8(uint64_t size, uint8_t* ptr);
+
+/* String functions */
+size_t SLAMP_strlen(const char *str);
+char* SLAMP_strchr(char *s, int c);
+char* SLAMP_strrchr(char *s, int c);
+int SLAMP_strcmp(const char *s1, const char *s2);
+int SLAMP_strncmp(const char *s1, const char *s2, size_t n);
+char* SLAMP_strcpy(char *dest, const char *src);
+char* SLAMP_strncpy(char *dest, const char *src, size_t n);
+char* SLAMP_strcat(char *s1, const char *s2);
+char* SLAMP_strncat(char *s1, const char *s2, size_t n);
+char* SLAMP_strstr(char *s1, char *s2);
+size_t SLAMP_strspn(const char *s1, const char *s2);
+size_t SLAMP_strcspn(const char *s1, const char *s2);
+char* SLAMP_strtok(char *s, const char *delim);
+double SLAMP_strtod(const char *nptr, char **endptr);
+long int SLAMP_strtol(const char *nptr, char **endptr, int base);
+char* SLAMP_strpbrk(char *s1, char *s2);
+
+/* Mem* and b* functions */
+void *SLAMP_memset (void *dest, int c, size_t n);
+void *SLAMP_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP___builtin_memcpy (void *dest, const void *src, size_t n);
+void *SLAMP_memmove (void *dest, const void *src, size_t n);
+int   SLAMP_memcmp(const void *s1, const void *s2, size_t n);
+void* SLAMP_memchr(void* ptr, int value, size_t num);
+void* SLAMP___rawmemchr(void* ptr, int value);
+
+void  SLAMP_bzero(void *s, size_t n);
+void  SLAMP_bcopy(const void *s1, void *s2, size_t n);
+
+/* IO */
+ssize_t SLAMP_read(int fd, void *buf, size_t count);
+int     SLAMP_open(const char *pathname, int flags, mode_t mode);
+int     SLAMP_close(int fd);
+ssize_t SLAMP_write(int fd, const void *buf, size_t count);
+off_t   SLAMP_lseek(int fildes, off_t offset, int whence);
+
+FILE *  SLAMP_fopen(const char *path, const char *mode);
+FILE *  SLAMP_fopen64(const char *path, const char *mode);
+FILE *  SLAMP_freopen(const char *path, const char *mode, FILE* stream);
+int     SLAMP_fflush(FILE *stream);
+int     SLAMP_fclose(FILE *stream);
+int     SLAMP_ferror(FILE *stream);
+int     SLAMP_feof(FILE *stream);
+long    SLAMP_ftell(FILE *stream);
+size_t  SLAMP_fread(void * ptr, size_t size, size_t nitems, FILE *stream);
+size_t  SLAMP_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+int     SLAMP_fseek(FILE *stream, long offset, int whence);
+void    SLAMP_rewind(FILE *stream);
+
+int     SLAMP_fgetc(FILE *stream);
+int     SLAMP_fputc(int c, FILE *stream);
+char *  SLAMP_fgets(char *s, int n, FILE *stream);
+int     SLAMP_fputs(const char *s, FILE *stream);
+
+int     SLAMP_ungetc(int c, FILE *stream);
+int     SLAMP_putchar(int c);
+int     SLAMP_getchar(void);
+
+int     SLAMP_fileno(FILE *stream);
+char *  SLAMP_gets(char *s);
+int     SLAMP_puts(const char *s);
+
+int     SLAMP_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int     SLAMP_remove(const char *path);
+
+void    SLAMP_setbuf(FILE * stream, char * buf);
+void    SLAMP_setvbuf(FILE * stream, char * buf, int mode, size_t size);
+char * SLAMP_tmpnam(char *s);
+FILE* SLAMP_tmpfile(void);
+char *  SLAMP_ttyname(int fildes);
+
+FILE *  SLAMP_fdopen(int fildes, const char *mode);
+void    SLAMP_clearerr(FILE *stream);
+
+int SLAMP_truncate(const char *path, off_t length);
+int SLAMP_ftruncate(int fildes, off_t length);
+
+int SLAMP_dup(int oldfd);
+int SLAMP_dup2(int oldfd, int newfd);
+int SLAMP_pipe(int filedes[2]);
+
+int SLAMP_chmod(const char *path, mode_t mode);
+int SLAMP_fchmod(int fildes, mode_t mode);
+int SLAMP_fchown(int fd, uid_t owner, gid_t group);
+int SLAMP_access(const char *pathname, int mode);
+long SLAMP_pathconf(char *path, int name);
+int SLAMP_mkdir(const char *pathname, mode_t mode);
+int SLAMP_rmdir(const char *pathname);
+mode_t SLAMP_umask(mode_t mask);
+int SLAMP_fcntl(int fd, int cmd, struct flock *lock);
+
+DIR* SLAMP_opendir(const char* name);
+struct dirent* SLAMP_readdir(DIR *dirp);
+struct dirent64* SLAMP_readdir64(DIR *dirp);
+int SLAMP_closedir(DIR* dirp);
+
+/* Printf */
+int SLAMP_printf(const char *format, ...);
+int SLAMP_fprintf(FILE *stream, const char *format, ...);
+int SLAMP_sprintf(char *str, const char *format, ...);
+int SLAMP_snprintf(char *str, size_t size, const char *format, ...);
+
+int SLAMP_vprintf(const char *format, va_list ap);
+int SLAMP_vfprintf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vsprintf(char *str, const char *format, va_list ap);
+int SLAMP_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+
+/* Scanf */
+int SLAMP_fscanf(FILE *stream, const char *format, ... );
+int SLAMP_scanf(const char *format, ... );
+int SLAMP_sscanf(const char *s, const char *format, ... );
+int SLAMP___isoc99_sscanf(const char *s, const char *format, ... );
+
+int SLAMP_vfscanf(FILE *stream, const char *format, va_list ap);
+int SLAMP_vscanf(const char *format, va_list ap);
+int SLAMP_vsscanf(const char *s, const char *format, va_list ap);
+
+/* Time */
+time_t SLAMP_time(time_t *t);
+struct tm *SLAMP_localtime(const time_t *timer);
+struct lconv* SLAMP_localeconv();
+struct tm *SLAMP_gmtime(const time_t *timer);
+int SLAMP_gettimeofday(struct timeval *tv, struct timezone *tz);
+
+/* Math */
+double SLAMP_ldexp(double x, int exp);
+float  SLAMP_ldexpf(float x, int exp);
+long double SLAMP_ldexpl(long double x, int exp);
+double SLAMP_log10(double x);
+float  SLAMP_log10f(float x);
+long double SLAMP_log10l(long double x);
+double SLAMP_log(double x);
+float SLAMP_logf(float x);
+long double SLAMP_logl(long double x);
+
+double SLAMP_exp(double x);
+float SLAMP_expf(float x);
+long double SLAMP_expl(long double x);
+
+double SLAMP_cos(double x);
+float SLAMP_cosf(float x);
+long double SLAMP_cosl(long double x);
+double SLAMP_sin(double x);
+double SLAMP_tan(double x);
+float SLAMP_sinf(float x);
+long double SLAMP_sinl(long double x);
+
+double SLAMP_atan(double x);
+float SLAMP_atanf(float x);
+long double SLAMP_atanl(long double x);
+
+double SLAMP_floor(double x);
+float SLAMP_floorf(float x);
+long double SLAMP_floorl(long double x);
+double SLAMP_ceil(double x);
+float SLAMP_ceilf(float x);
+long double SLAMP_ceill(long double x);
+
+double SLAMP_atan2(double y, double x);
+float SLAMP_atan2f(float y, float x);
+long double SLAMP_atan2l(long double y, long double x);
+
+double SLAMP_sqrt(double x);
+float SLAMP_sqrtf(float x);
+long double SLAMP_sqrtl(long double x);
+
+double SLAMP_pow(double x, double y);
+float SLAMP_powf(float x, float y);
+long double SLAMP_powl(long double x, long double y);
+
+double SLAMP_fabs(double x);
+float SLAMP_fabsf(float x);
+long double SLAMP_fabsl(long double x);
+
+double SLAMP_modf(double x, double *iptr);
+float SLAMP_modff(float x, float *iptr);
+long double SLAMP_modfl(long double x, long double *iptr);
+
+double SLAMP_fmod(double x, double y);
+
+double SLAMP_frexp(double num, int *exp);
+float SLAMP_frexpf(float num, int *exp);
+long double SLAMP_frexpl(long double num, int *exp);
+
+int SLAMP_isnan();
+
+/* MISC */
+char *SLAMP_getenv(const char *name);
+int SLAMP_putenv(char* string);
+char *SLAMP_getcwd(char *buf, size_t size);
+char* SLAMP_strerror(int errnum);
+void SLAMP_exit(int status);
+void SLAMP__exit(int status);
+int  SLAMP_link(const char *oldpath, const char *newpath);
+int  SLAMP_unlink(const char *pathname);
+int  SLAMP_isatty(int desc);
+int SLAMP_setuid(uid_t uid);
+uid_t SLAMP_getuid(void);
+uid_t SLAMP_geteuid(void);
+int SLAMP_setgid(gid_t gid);
+gid_t SLAMP_getgid(void);
+gid_t SLAMP_getegid(void);
+pid_t SLAMP_getpid(void);
+int SLAMP_chdir(const char *path);
+int SLAMP_execl(const char *path, const char *arg0, ... /*, (char *)0 */);
+int SLAMP_execv(const char *path, char *const argv[]);
+int SLAMP_execvp(const char *file, char *const argv[]);
+int SLAMP_kill(pid_t pid, int sig);
+pid_t SLAMP_fork(void);
+sighandler_t SLAMP___sysv_signal(int signum, sighandler_t handler);
+pid_t SLAMP_waitpid(pid_t pid, int* status, int options);
+void SLAMP_qsort(void* base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+int SLAMP_ioctl(int d, int request, ...);
+unsigned int SLAMP_sleep(unsigned int seconds);
+char* SLAMP_gcvt(double number, size_t ndigit, char* buf);
+char* SLAMP_nl_langinfo(nl_item item);
+
+/* Compiler/Glibc Internals */
+void SLAMP___assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);
+const unsigned short int **SLAMP___ctype_b_loc(void);
+int SLAMP__IO_getc(_IO_FILE * __fp);
+int SLAMP__IO_putc(int __c, _IO_FILE *__fp);
+int* SLAMP___errno_location (void);
+
+int SLAMP___fxstat (int __ver, int __fildes, struct stat *__stat_buf);
+int SLAMP___xstat (int __ver, __const char *__filename, struct stat *__stat_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLAMP_HOOKS_H */
diff --git a/liberty/lib/SLAMP/queue_benchmark.txt b/liberty/lib/SLAMP/queue_benchmark.txt
new file mode 100644
index 00000000..a1fbac6c
--- /dev/null
+++ b/liberty/lib/SLAMP/queue_benchmark.txt
@@ -0,0 +1,1100 @@
+---- Running throughput benchmarks (higher is better) ----
+     boost::lockfree::spsc_queue, 1,s: 107,997,734 msg/sec
+     boost::lockfree::spsc_queue, 1,i: 109,358,919 msg/sec
+          boost::lockfree::queue, 1,s:   4,048,308 msg/sec
+          boost::lockfree::queue, 1,i:   4,090,655 msg/sec
+          boost::lockfree::queue, 2,s:   3,582,047 msg/sec
+          boost::lockfree::queue, 2,i:   3,566,650 msg/sec
+          boost::lockfree::queue, 3,s:   3,451,386 msg/sec
+          boost::lockfree::queue, 3,i:   3,471,721 msg/sec
+          boost::lockfree::queue, 4,s:   3,265,429 msg/sec
+          boost::lockfree::queue, 4,i:   3,352,379 msg/sec
+          boost::lockfree::queue, 5,s:   3,168,874 msg/sec
+          boost::lockfree::queue, 5,i:   3,073,243 msg/sec
+          boost::lockfree::queue, 6,s:   2,981,684 msg/sec
+          boost::lockfree::queue, 6,i:   2,954,838 msg/sec
+          boost::lockfree::queue, 7,s:   2,848,137 msg/sec
+          boost::lockfree::queue, 7,i:   2,884,899 msg/sec
+          boost::lockfree::queue, 8,s:   1,315,964 msg/sec
+          boost::lockfree::queue, 8,i:   2,170,027 msg/sec
+          boost::lockfree::queue, 9,s:   1,212,512 msg/sec
+          boost::lockfree::queue, 9,i:   1,748,269 msg/sec
+          boost::lockfree::queue,10,s:   1,172,987 msg/sec
+          boost::lockfree::queue,10,i:   1,258,711 msg/sec
+          boost::lockfree::queue,11,s:   1,180,074 msg/sec
+          boost::lockfree::queue,11,i:   1,163,508 msg/sec
+          boost::lockfree::queue,12,s:   1,221,812 msg/sec
+          boost::lockfree::queue,12,i:   1,059,277 msg/sec
+          boost::lockfree::queue,13,s:   1,251,914 msg/sec
+          boost::lockfree::queue,13,i:   1,039,787 msg/sec
+          boost::lockfree::queue,14,s:   1,279,827 msg/sec
+          boost::lockfree::queue,14,i:     999,276 msg/sec
+          boost::lockfree::queue,15,s:   1,297,184 msg/sec
+          boost::lockfree::queue,15,i:   1,088,072 msg/sec
+          boost::lockfree::queue,16,s:   1,264,412 msg/sec
+          boost::lockfree::queue,16,i:   1,103,424 msg/sec
+          boost::lockfree::queue,17,s:   1,217,296 msg/sec
+          boost::lockfree::queue,17,i:   1,123,018 msg/sec
+          boost::lockfree::queue,18,s:   1,166,488 msg/sec
+          boost::lockfree::queue,18,i:   1,134,237 msg/sec
+          boost::lockfree::queue,19,s:   1,099,566 msg/sec
+          boost::lockfree::queue,19,i:   1,142,602 msg/sec
+          boost::lockfree::queue,20,s:   1,028,095 msg/sec
+          boost::lockfree::queue,20,i:   1,179,536 msg/sec
+          boost::lockfree::queue,21,s:     996,655 msg/sec
+          boost::lockfree::queue,21,i:   1,158,180 msg/sec
+          boost::lockfree::queue,22,s:     989,882 msg/sec
+          boost::lockfree::queue,22,i:   1,159,260 msg/sec
+          boost::lockfree::queue,23,s:     972,800 msg/sec
+          boost::lockfree::queue,23,i:   1,187,182 msg/sec
+          boost::lockfree::queue,24,s:     997,166 msg/sec
+          boost::lockfree::queue,24,i:   1,194,829 msg/sec
+          boost::lockfree::queue,25,s:     996,421 msg/sec
+          boost::lockfree::queue,25,i:   1,272,264 msg/sec
+          boost::lockfree::queue,26,s:     942,650 msg/sec
+          boost::lockfree::queue,26,i:   1,176,117 msg/sec
+          boost::lockfree::queue,27,s:     945,707 msg/sec
+          boost::lockfree::queue,27,i:   1,175,990 msg/sec
+          boost::lockfree::queue,28,s:     903,794 msg/sec
+          boost::lockfree::queue,28,i:   1,101,815 msg/sec
+                  TicketSpinlock, 1,s:   3,347,824 msg/sec
+                  TicketSpinlock, 1,i:   3,347,547 msg/sec
+                  TicketSpinlock, 2,s:   2,967,686 msg/sec
+                  TicketSpinlock, 2,i:   2,961,449 msg/sec
+                  TicketSpinlock, 3,s:   2,520,313 msg/sec
+                  TicketSpinlock, 3,i:   2,550,617 msg/sec
+                  TicketSpinlock, 4,s:   2,210,679 msg/sec
+                  TicketSpinlock, 4,i:   2,243,531 msg/sec
+                  TicketSpinlock, 5,s:   2,049,747 msg/sec
+                  TicketSpinlock, 5,i:   2,095,328 msg/sec
+                  TicketSpinlock, 6,s:   1,875,237 msg/sec
+                  TicketSpinlock, 6,i:   1,944,668 msg/sec
+                  TicketSpinlock, 7,s:   1,753,580 msg/sec
+                  TicketSpinlock, 7,i:   1,817,202 msg/sec
+                  TicketSpinlock, 8,s:   1,277,627 msg/sec
+                  TicketSpinlock, 8,i:   1,294,381 msg/sec
+                  TicketSpinlock, 9,s:   1,222,606 msg/sec
+                  TicketSpinlock, 9,i:   1,239,650 msg/sec
+                  TicketSpinlock,10,s:   1,203,840 msg/sec
+                  TicketSpinlock,10,i:   1,197,460 msg/sec
+                  TicketSpinlock,11,s:   1,169,283 msg/sec
+                  TicketSpinlock,11,i:   1,156,647 msg/sec
+                  TicketSpinlock,12,s:   1,165,389 msg/sec
+                  TicketSpinlock,12,i:   1,133,687 msg/sec
+                  TicketSpinlock,13,s:   1,132,670 msg/sec
+                  TicketSpinlock,13,i:   1,128,463 msg/sec
+                  TicketSpinlock,14,s:   1,147,855 msg/sec
+                  TicketSpinlock,14,i:   1,117,921 msg/sec
+                  TicketSpinlock,15,s:   1,148,721 msg/sec
+                  TicketSpinlock,15,i:   1,127,920 msg/sec
+                  TicketSpinlock,16,s:   1,152,958 msg/sec
+                  TicketSpinlock,16,i:   1,139,066 msg/sec
+                  TicketSpinlock,17,s:   1,161,394 msg/sec
+                  TicketSpinlock,17,i:   1,183,274 msg/sec
+                  TicketSpinlock,18,s:   1,174,699 msg/sec
+                  TicketSpinlock,18,i:   1,214,113 msg/sec
+                  TicketSpinlock,19,s:   1,175,616 msg/sec
+                  TicketSpinlock,19,i:   1,215,555 msg/sec
+                  TicketSpinlock,20,s:   1,158,764 msg/sec
+                  TicketSpinlock,20,i:   1,216,226 msg/sec
+                  TicketSpinlock,21,s:   1,159,335 msg/sec
+                  TicketSpinlock,21,i:   1,249,847 msg/sec
+                  TicketSpinlock,22,s:   1,143,440 msg/sec
+                  TicketSpinlock,22,i:   1,211,246 msg/sec
+                  TicketSpinlock,23,s:   1,151,665 msg/sec
+                  TicketSpinlock,23,i:   1,198,510 msg/sec
+                  TicketSpinlock,24,s:   1,149,453 msg/sec
+                  TicketSpinlock,24,i:   1,213,075 msg/sec
+                  TicketSpinlock,25,s:   1,138,716 msg/sec
+                  TicketSpinlock,25,i:   1,208,927 msg/sec
+                  TicketSpinlock,26,s:   1,171,849 msg/sec
+                  TicketSpinlock,26,i:   1,191,843 msg/sec
+                  TicketSpinlock,27,s:   1,147,152 msg/sec
+                  TicketSpinlock,27,i:   1,208,291 msg/sec
+                  TicketSpinlock,28,s:   1,157,333 msg/sec
+                  TicketSpinlock,28,i:   1,193,849 msg/sec
+   moodycamel::ReaderWriterQueue, 1,s: 225,144,209 msg/sec
+   moodycamel::ReaderWriterQueue, 1,i: 102,397,802 msg/sec
+     moodycamel::ConcurrentQueue, 1,s:  13,368,618 msg/sec
+     moodycamel::ConcurrentQueue, 1,i:   9,999,354 msg/sec
+     moodycamel::ConcurrentQueue, 2,s:  10,246,428 msg/sec
+     moodycamel::ConcurrentQueue, 2,i:  10,144,610 msg/sec
+     moodycamel::ConcurrentQueue, 3,s:   9,394,547 msg/sec
+     moodycamel::ConcurrentQueue, 3,i:   9,307,908 msg/sec
+     moodycamel::ConcurrentQueue, 4,s:   9,536,518 msg/sec
+     moodycamel::ConcurrentQueue, 4,i:   9,464,837 msg/sec
+     moodycamel::ConcurrentQueue, 5,s:  23,129,485 msg/sec
+     moodycamel::ConcurrentQueue, 5,i:  22,768,199 msg/sec
+     moodycamel::ConcurrentQueue, 6,s:   9,474,407 msg/sec
+     moodycamel::ConcurrentQueue, 6,i:   9,484,694 msg/sec
+     moodycamel::ConcurrentQueue, 7,s:   9,404,419 msg/sec
+     moodycamel::ConcurrentQueue, 7,i:  18,979,667 msg/sec
+     moodycamel::ConcurrentQueue, 8,s:   5,287,332 msg/sec
+     moodycamel::ConcurrentQueue, 8,i:   6,403,588 msg/sec
+     moodycamel::ConcurrentQueue, 9,s:   4,810,655 msg/sec
+     moodycamel::ConcurrentQueue, 9,i:   5,410,923 msg/sec
+     moodycamel::ConcurrentQueue,10,s:  11,319,209 msg/sec
+     moodycamel::ConcurrentQueue,10,i:   5,000,012 msg/sec
+     moodycamel::ConcurrentQueue,11,s:   9,739,263 msg/sec
+     moodycamel::ConcurrentQueue,11,i:  13,600,492 msg/sec
+     moodycamel::ConcurrentQueue,12,s:  12,174,409 msg/sec
+     moodycamel::ConcurrentQueue,12,i:   4,762,923 msg/sec
+     moodycamel::ConcurrentQueue,13,s:  13,138,679 msg/sec
+     moodycamel::ConcurrentQueue,13,i:  10,438,944 msg/sec
+     moodycamel::ConcurrentQueue,14,s:   9,505,382 msg/sec
+     moodycamel::ConcurrentQueue,14,i:  14,061,583 msg/sec
+     moodycamel::ConcurrentQueue,15,s:  22,268,559 msg/sec
+     moodycamel::ConcurrentQueue,15,i:  27,396,194 msg/sec
+     moodycamel::ConcurrentQueue,16,s:  39,867,824 msg/sec
+     moodycamel::ConcurrentQueue,16,i:   9,987,406 msg/sec
+     moodycamel::ConcurrentQueue,17,s:   4,815,220 msg/sec
+     moodycamel::ConcurrentQueue,17,i:   5,323,513 msg/sec
+     moodycamel::ConcurrentQueue,18,s:  31,809,138 msg/sec
+     moodycamel::ConcurrentQueue,18,i:  37,599,636 msg/sec
+     moodycamel::ConcurrentQueue,19,s:   4,641,828 msg/sec
+     moodycamel::ConcurrentQueue,19,i:  25,964,670 msg/sec
+     moodycamel::ConcurrentQueue,20,s:   4,699,633 msg/sec
+     moodycamel::ConcurrentQueue,20,i:  11,341,493 msg/sec
+     moodycamel::ConcurrentQueue,21,s:   9,199,439 msg/sec
+     moodycamel::ConcurrentQueue,21,i:  25,546,446 msg/sec
+     moodycamel::ConcurrentQueue,22,s:  40,199,001 msg/sec
+     moodycamel::ConcurrentQueue,22,i:  14,043,025 msg/sec
+     moodycamel::ConcurrentQueue,23,s:  16,944,418 msg/sec
+     moodycamel::ConcurrentQueue,23,i:  43,708,787 msg/sec
+     moodycamel::ConcurrentQueue,24,s:   4,560,747 msg/sec
+     moodycamel::ConcurrentQueue,24,i:   6,968,251 msg/sec
+     moodycamel::ConcurrentQueue,25,s:  12,175,776 msg/sec
+     moodycamel::ConcurrentQueue,25,i:   7,134,059 msg/sec
+     moodycamel::ConcurrentQueue,26,s:  33,074,197 msg/sec
+     moodycamel::ConcurrentQueue,26,i:  16,678,528 msg/sec
+     moodycamel::ConcurrentQueue,27,s:  48,724,662 msg/sec
+     moodycamel::ConcurrentQueue,27,i:   7,558,508 msg/sec
+     moodycamel::ConcurrentQueue,28,s:   4,540,667 msg/sec
+     moodycamel::ConcurrentQueue,28,i:  21,423,380 msg/sec
+                pthread_spinlock, 1,s:   1,388,219 msg/sec
+                pthread_spinlock, 1,i:   1,590,798 msg/sec
+                pthread_spinlock, 2,s:   4,061,346 msg/sec
+                pthread_spinlock, 2,i:   4,111,464 msg/sec
+                pthread_spinlock, 3,s:   3,707,084 msg/sec
+                pthread_spinlock, 3,i:   3,657,961 msg/sec
+                pthread_spinlock, 4,s:   3,356,248 msg/sec
+                pthread_spinlock, 4,i:   3,411,467 msg/sec
+                pthread_spinlock, 5,s:   2,922,106 msg/sec
+                pthread_spinlock, 5,i:   3,012,059 msg/sec
+                pthread_spinlock, 6,s:   2,814,872 msg/sec
+                pthread_spinlock, 6,i:   2,807,978 msg/sec
+                pthread_spinlock, 7,s:   2,277,902 msg/sec
+                pthread_spinlock, 7,i:   2,424,606 msg/sec
+pthread_spinlock: producers: 8: consumer 1 received too few messages: 0.03% of expected.
+                pthread_spinlock, 8,s:   1,713,429 msg/sec
+pthread_spinlock: producers: 8: consumer 2 received too few messages: 0.00% of expected.
+                pthread_spinlock, 8,i:   2,099,709 msg/sec
+pthread_spinlock: producers: 9: consumer 2 received too few messages: 0.08% of expected.
+pthread_spinlock: producers: 9: consumer 0 received too few messages: 0.04% of expected.
+                pthread_spinlock, 9,s:   1,702,071 msg/sec
+pthread_spinlock: producers: 9: consumer 1 received too few messages: 0.01% of expected.
+                pthread_spinlock, 9,i:   2,129,815 msg/sec
+pthread_spinlock: producers: 10: consumer 1 received too few messages: 0.06% of expected.
+pthread_spinlock: producers: 10: consumer 3 received too few messages: 0.03% of expected.
+pthread_spinlock: producers: 10: consumer 0 received too few messages: 0.04% of expected.
+                pthread_spinlock,10,s:   1,897,704 msg/sec
+pthread_spinlock: producers: 10: consumer 5 received too few messages: 0.01% of expected.
+pthread_spinlock: producers: 10: consumer 6 received too few messages: 0.03% of expected.
+                pthread_spinlock,10,i:   2,136,486 msg/sec
+pthread_spinlock: producers: 11: consumer 0 received too few messages: 0.08% of expected.
+                pthread_spinlock,11,s:   1,917,518 msg/sec
+pthread_spinlock: producers: 11: consumer 4 received too few messages: 0.02% of expected.
+                pthread_spinlock,11,i:   2,039,850 msg/sec
+                pthread_spinlock,12,s:   1,878,326 msg/sec
+pthread_spinlock: producers: 12: consumer 1 received too few messages: 0.02% of expected.
+                pthread_spinlock,12,i:   2,017,794 msg/sec
+pthread_spinlock: producers: 13: consumer 0 received too few messages: 0.10% of expected.
+pthread_spinlock: producers: 13: consumer 0 received too few messages: 0.03% of expected.
+                pthread_spinlock,13,s:   1,617,323 msg/sec
+pthread_spinlock: producers: 13: consumer 5 received too few messages: 0.02% of expected.
+                pthread_spinlock,13,i:   2,007,359 msg/sec
+                pthread_spinlock,14,s:   1,730,125 msg/sec
+pthread_spinlock: producers: 14: consumer 3 received too few messages: 0.05% of expected.
+pthread_spinlock: producers: 14: consumer 4 received too few messages: 0.10% of expected.
+                pthread_spinlock,14,i:   1,818,811 msg/sec
+pthread_spinlock: producers: 15: consumer 13 received too few messages: 0.06% of expected.
+pthread_spinlock: producers: 15: consumer 14 received too few messages: 0.08% of expected.
+                pthread_spinlock,15,s:   1,788,437 msg/sec
+                pthread_spinlock,15,i:   1,896,966 msg/sec
+pthread_spinlock: producers: 16: consumer 12 received too few messages: 0.09% of expected.
+                pthread_spinlock,16,s:   1,778,092 msg/sec
+                pthread_spinlock,16,i:   1,937,498 msg/sec
+pthread_spinlock: producers: 17: consumer 11 received too few messages: 0.09% of expected.
+pthread_spinlock: producers: 17: consumer 15 received too few messages: 0.09% of expected.
+                pthread_spinlock,17,s:   1,805,306 msg/sec
+                pthread_spinlock,17,i:   1,967,797 msg/sec
+pthread_spinlock: producers: 18: consumer 16 received too few messages: 0.06% of expected.
+pthread_spinlock: producers: 18: consumer 17 received too few messages: 0.09% of expected.
+pthread_spinlock: producers: 18: consumer 15 received too few messages: 0.07% of expected.
+pthread_spinlock: producers: 18: consumer 14 received too few messages: 0.06% of expected.
+                pthread_spinlock,18,s:   1,897,631 msg/sec
+                pthread_spinlock,18,i:   1,971,578 msg/sec
+pthread_spinlock: producers: 19: consumer 16 received too few messages: 0.10% of expected.
+pthread_spinlock: producers: 19: consumer 10 received too few messages: 0.10% of expected.
+pthread_spinlock: producers: 19: consumer 11 received too few messages: 0.09% of expected.
+pthread_spinlock: producers: 19: consumer 16 received too few messages: 0.10% of expected.
+pthread_spinlock: producers: 19: consumer 13 received too few messages: 0.08% of expected.
+                pthread_spinlock,19,s:   1,954,765 msg/sec
+pthread_spinlock: producers: 19: consumer 6 received too few messages: 0.08% of expected.
+                pthread_spinlock,19,i:   2,002,153 msg/sec
+pthread_spinlock: producers: 20: consumer 12 received too few messages: 0.02% of expected.
+                pthread_spinlock,20,s:   1,925,179 msg/sec
+pthread_spinlock: producers: 20: consumer 2 received too few messages: 0.03% of expected.
+                pthread_spinlock,20,i:   1,988,383 msg/sec
+                pthread_spinlock,21,s:   2,008,688 msg/sec
+pthread_spinlock: producers: 21: consumer 7 received too few messages: 0.09% of expected.
+                pthread_spinlock,21,i:   1,980,480 msg/sec
+pthread_spinlock: producers: 22: consumer 7 received too few messages: 0.04% of expected.
+                pthread_spinlock,22,s:   1,969,265 msg/sec
+pthread_spinlock: producers: 22: consumer 19 received too few messages: 0.03% of expected.
+pthread_spinlock: producers: 22: consumer 4 received too few messages: 0.03% of expected.
+                pthread_spinlock,22,i:   1,946,497 msg/sec
+                pthread_spinlock,23,s:   1,968,276 msg/sec
+                pthread_spinlock,23,i:   1,960,031 msg/sec
+pthread_spinlock: producers: 24: consumer 12 received too few messages: 0.06% of expected.
+                pthread_spinlock,24,s:   1,865,849 msg/sec
+pthread_spinlock: producers: 24: consumer 18 received too few messages: 0.04% of expected.
+pthread_spinlock: producers: 24: consumer 4 received too few messages: 0.03% of expected.
+pthread_spinlock: producers: 24: consumer 5 received too few messages: 0.04% of expected.
+                pthread_spinlock,24,i:   1,933,067 msg/sec
+pthread_spinlock: producers: 25: consumer 4 received too few messages: 0.08% of expected.
+pthread_spinlock: producers: 25: consumer 7 received too few messages: 0.09% of expected.
+                pthread_spinlock,25,s:   1,796,967 msg/sec
+pthread_spinlock: producers: 25: consumer 14 received too few messages: 0.02% of expected.
+                pthread_spinlock,25,i:   1,906,613 msg/sec
+                pthread_spinlock,26,s:   1,715,120 msg/sec
+pthread_spinlock: producers: 26: consumer 3 received too few messages: 0.09% of expected.
+                pthread_spinlock,26,i:   1,744,655 msg/sec
+                pthread_spinlock,27,s:   1,396,728 msg/sec
+                pthread_spinlock,27,i:   1,460,071 msg/sec
+                pthread_spinlock,28,s:   1,397,343 msg/sec
+                pthread_spinlock,28,i:   1,453,740 msg/sec
+                      std::mutex, 1,s:   4,831,124 msg/sec
+                      std::mutex, 1,i:   4,686,462 msg/sec
+                      std::mutex, 2,s:   5,043,814 msg/sec
+                      std::mutex, 2,i:   5,020,252 msg/sec
+                      std::mutex, 3,s:   3,908,694 msg/sec
+                      std::mutex, 3,i:   3,895,097 msg/sec
+                      std::mutex, 4,s:   3,554,815 msg/sec
+                      std::mutex, 4,i:   3,528,514 msg/sec
+                      std::mutex, 5,s:   3,843,170 msg/sec
+                      std::mutex, 5,i:   3,771,042 msg/sec
+                      std::mutex, 6,s:   3,767,452 msg/sec
+                      std::mutex, 6,i:   3,667,091 msg/sec
+                      std::mutex, 7,s:   3,610,762 msg/sec
+                      std::mutex, 7,i:   3,477,284 msg/sec
+                      std::mutex, 8,s:   2,197,057 msg/sec
+                      std::mutex, 8,i:   2,246,655 msg/sec
+                      std::mutex, 9,s:   1,893,438 msg/sec
+                      std::mutex, 9,i:   1,950,847 msg/sec
+                      std::mutex,10,s:   1,787,108 msg/sec
+                      std::mutex,10,i:   1,865,565 msg/sec
+                      std::mutex,11,s:   1,741,380 msg/sec
+                      std::mutex,11,i:   1,807,413 msg/sec
+                      std::mutex,12,s:   1,749,876 msg/sec
+                      std::mutex,12,i:   1,804,944 msg/sec
+                      std::mutex,13,s:   1,759,121 msg/sec
+                      std::mutex,13,i:   1,769,137 msg/sec
+                      std::mutex,14,s:   1,779,333 msg/sec
+                      std::mutex,14,i:   1,776,040 msg/sec
+                      std::mutex,15,s:   1,734,586 msg/sec
+                      std::mutex,15,i:   1,718,733 msg/sec
+                      std::mutex,16,s:   1,709,260 msg/sec
+                      std::mutex,16,i:   1,714,574 msg/sec
+                      std::mutex,17,s:   1,694,088 msg/sec
+                      std::mutex,17,i:   1,702,783 msg/sec
+                      std::mutex,18,s:   1,700,218 msg/sec
+                      std::mutex,18,i:   1,703,590 msg/sec
+                      std::mutex,19,s:   1,689,770 msg/sec
+                      std::mutex,19,i:   1,685,577 msg/sec
+                      std::mutex,20,s:   1,715,029 msg/sec
+                      std::mutex,20,i:   1,668,976 msg/sec
+                      std::mutex,21,s:   1,727,414 msg/sec
+                      std::mutex,21,i:   1,684,466 msg/sec
+                      std::mutex,22,s:   1,706,687 msg/sec
+                      std::mutex,22,i:   1,663,748 msg/sec
+                      std::mutex,23,s:   1,692,779 msg/sec
+                      std::mutex,23,i:   1,651,100 msg/sec
+                      std::mutex,24,s:   1,676,927 msg/sec
+                      std::mutex,24,i:   1,647,381 msg/sec
+                      std::mutex,25,s:   1,664,716 msg/sec
+                      std::mutex,25,i:   1,626,701 msg/sec
+                      std::mutex,26,s:   1,663,565 msg/sec
+                      std::mutex,26,i:   1,618,815 msg/sec
+                      std::mutex,27,s:   1,670,749 msg/sec
+                      std::mutex,27,i:   1,620,646 msg/sec
+                      std::mutex,28,s:   1,658,071 msg/sec
+                      std::mutex,28,i:   1,604,433 msg/sec
+                 tbb::spin_mutex, 1,s:  34,633,531 msg/sec
+                 tbb::spin_mutex, 1,i:   8,803,958 msg/sec
+                 tbb::spin_mutex, 2,s:  30,094,896 msg/sec
+                 tbb::spin_mutex, 2,i:  29,262,071 msg/sec
+                 tbb::spin_mutex, 3,s:  13,875,600 msg/sec
+                 tbb::spin_mutex, 3,i:  14,174,790 msg/sec
+                 tbb::spin_mutex, 4,s:   5,751,810 msg/sec
+                 tbb::spin_mutex, 4,i:   6,723,603 msg/sec
+                 tbb::spin_mutex, 5,s:   2,317,003 msg/sec
+                 tbb::spin_mutex, 5,i:   4,720,911 msg/sec
+tbb::spin_mutex: producers: 6: consumer 3 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex, 6,s:   2,993,706 msg/sec
+tbb::spin_mutex: producers: 6: consumer 4 received too few messages: 0.02% of expected.
+                 tbb::spin_mutex, 6,i:   3,336,064 msg/sec
+                 tbb::spin_mutex, 7,s:   2,436,489 msg/sec
+                 tbb::spin_mutex, 7,i:   1,506,125 msg/sec
+                 tbb::spin_mutex, 8,s:     789,866 msg/sec
+tbb::spin_mutex: producers: 8: consumer 4 received too few messages: 0.07% of expected.
+tbb::spin_mutex: producers: 8: consumer 4 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex, 8,i:     829,718 msg/sec
+                 tbb::spin_mutex, 9,s:     161,273 msg/sec
+                 tbb::spin_mutex, 9,i:     412,053 msg/sec
+                 tbb::spin_mutex,10,s:      99,406 msg/sec
+                 tbb::spin_mutex,10,i:     201,820 msg/sec
+                 tbb::spin_mutex,11,s:      95,459 msg/sec
+                 tbb::spin_mutex,11,i:     145,884 msg/sec
+                 tbb::spin_mutex,12,s:      95,252 msg/sec
+                 tbb::spin_mutex,12,i:     111,953 msg/sec
+                 tbb::spin_mutex,13,s:      95,234 msg/sec
+                 tbb::spin_mutex,13,i:      94,810 msg/sec
+                 tbb::spin_mutex,14,s:      87,071 msg/sec
+                 tbb::spin_mutex,14,i:      90,292 msg/sec
+^[[6~tbb::spin_mutex: producers: 15: consumer 2 received too few messages: 0.10% of expected.
+tbb::spin_mutex: producers: 15: consumer 8 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex,15,s:      85,940 msg/sec
+                 tbb::spin_mutex,15,i:      87,511 msg/sec
+                 tbb::spin_mutex,16,s:      85,171 msg/sec
+                 tbb::spin_mutex,16,i:      96,928 msg/sec
+tbb::spin_mutex: producers: 17: consumer 15 received too few messages: 0.06% of expected.
+tbb::spin_mutex: producers: 17: consumer 14 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex,17,s:      84,877 msg/sec
+                 tbb::spin_mutex,17,i:     102,681 msg/sec
+                 tbb::spin_mutex,18,s:      81,075 msg/sec
+                 tbb::spin_mutex,18,i:     105,120 msg/sec
+tbb::spin_mutex: producers: 19: consumer 13 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex,19,s:     108,166 msg/sec
+                 tbb::spin_mutex,19,i:     122,460 msg/sec
+                 tbb::spin_mutex,20,s:     103,006 msg/sec
+tbb::spin_mutex: producers: 20: consumer 0 received too few messages: 0.04% of expected.
+                 tbb::spin_mutex,20,i:     127,191 msg/sec
+tbb::spin_mutex: producers: 21: consumer 8 received too few messages: 0.09% of expected.
+                 tbb::spin_mutex,21,s:     104,653 msg/sec
+                 tbb::spin_mutex,21,i:     132,129 msg/sec
+                 tbb::spin_mutex,22,s:      92,899 msg/sec
+tbb::spin_mutex: producers: 22: consumer 4 received too few messages: 0.03% of expected.
+tbb::spin_mutex: producers: 22: consumer 18 received too few messages: 0.06% of expected.
+                 tbb::spin_mutex,22,i:     117,358 msg/sec
+tbb::spin_mutex: producers: 23: consumer 14 received too few messages: 0.03% of expected.
+                 tbb::spin_mutex,23,s:      92,578 msg/sec
+                 tbb::spin_mutex,23,i:      91,750 msg/sec
+tbb::spin_mutex: producers: 24: consumer 13 received too few messages: 0.06% of expected.
+                 tbb::spin_mutex,24,s:      89,071 msg/sec
+tbb::spin_mutex: producers: 24: consumer 4 received too few messages: 0.10% of expected.
+                 tbb::spin_mutex,24,i:      76,326 msg/sec
+                 tbb::spin_mutex,25,s:      74,687 msg/sec
+tbb::spin_mutex: producers: 25: consumer 6 received too few messages: 0.07% of expected.
+                 tbb::spin_mutex,25,i:      64,215 msg/sec
+                 tbb::spin_mutex,26,s:      65,585 msg/sec
+                 tbb::spin_mutex,26,i:      60,131 msg/sec
+                 tbb::spin_mutex,27,s:      63,543 msg/sec
+                 tbb::spin_mutex,27,i:      58,732 msg/sec
+                 tbb::spin_mutex,28,s:      62,861 msg/sec
+                 tbb::spin_mutex,28,i:      57,504 msg/sec
+   tbb::concurrent_bounded_queue, 1,s:   8,247,335 msg/sec
+   tbb::concurrent_bounded_queue, 1,i:   8,127,504 msg/sec
+   tbb::concurrent_bounded_queue, 2,s:   7,910,361 msg/sec
+   tbb::concurrent_bounded_queue, 2,i:   8,042,523 msg/sec
+   tbb::concurrent_bounded_queue, 3,s:   6,576,622 msg/sec
+   tbb::concurrent_bounded_queue, 3,i:   6,935,144 msg/sec
+   tbb::concurrent_bounded_queue, 4,s:   5,100,359 msg/sec
+   tbb::concurrent_bounded_queue, 4,i:   5,416,538 msg/sec
+   tbb::concurrent_bounded_queue, 5,s:   4,366,804 msg/sec
+   tbb::concurrent_bounded_queue, 5,i:   4,692,855 msg/sec
+   tbb::concurrent_bounded_queue, 6,s:   3,753,167 msg/sec
+   tbb::concurrent_bounded_queue, 6,i:   3,901,458 msg/sec
+   tbb::concurrent_bounded_queue, 7,s:   3,419,297 msg/sec
+   tbb::concurrent_bounded_queue, 7,i:   3,432,102 msg/sec
+   tbb::concurrent_bounded_queue, 8,s:   1,214,040 msg/sec
+tbb::concurrent_bounded_queue: producers: 8: consumer 4 received too few messages: 0.04% of expected.
+   tbb::concurrent_bounded_queue, 8,i:   2,916,297 msg/sec
+   tbb::concurrent_bounded_queue, 9,s:     873,003 msg/sec
+tbb::concurrent_bounded_queue: producers: 9: consumer 6 received too few messages: 0.07% of expected.
+   tbb::concurrent_bounded_queue, 9,i:   2,403,944 msg/sec
+   tbb::concurrent_bounded_queue,10,s:     756,434 msg/sec
+   tbb::concurrent_bounded_queue,10,i:   1,674,241 msg/sec
+   tbb::concurrent_bounded_queue,11,s:     678,623 msg/sec
+   tbb::concurrent_bounded_queue,11,i:   1,455,146 msg/sec
+   tbb::concurrent_bounded_queue,12,s:     613,767 msg/sec
+   tbb::concurrent_bounded_queue,12,i:   1,348,600 msg/sec
+   tbb::concurrent_bounded_queue,13,s:     615,369 msg/sec
+   tbb::concurrent_bounded_queue,13,i:   1,152,422 msg/sec
+   tbb::concurrent_bounded_queue,14,s:     577,159 msg/sec
+   tbb::concurrent_bounded_queue,14,i:   1,001,476 msg/sec
+   tbb::concurrent_bounded_queue,15,s:     655,450 msg/sec
+   tbb::concurrent_bounded_queue,15,i:   1,042,384 msg/sec
+   tbb::concurrent_bounded_queue,16,s:     732,790 msg/sec
+   tbb::concurrent_bounded_queue,16,i:   1,099,887 msg/sec
+   tbb::concurrent_bounded_queue,17,s:     805,787 msg/sec
+   tbb::concurrent_bounded_queue,17,i:   1,086,630 msg/sec
+   tbb::concurrent_bounded_queue,18,s:     857,035 msg/sec
+   tbb::concurrent_bounded_queue,18,i:   1,176,985 msg/sec
+   tbb::concurrent_bounded_queue,19,s:     885,873 msg/sec
+   tbb::concurrent_bounded_queue,19,i:   1,146,171 msg/sec
+   tbb::concurrent_bounded_queue,20,s:     892,738 msg/sec
+   tbb::concurrent_bounded_queue,20,i:   1,227,082 msg/sec
+   tbb::concurrent_bounded_queue,21,s:   1,139,013 msg/sec
+   tbb::concurrent_bounded_queue,21,i:   1,180,454 msg/sec
+   tbb::concurrent_bounded_queue,22,s:   1,174,013 msg/sec
+   tbb::concurrent_bounded_queue,22,i:   1,077,110 msg/sec
+   tbb::concurrent_bounded_queue,23,s:   1,069,171 msg/sec
+   tbb::concurrent_bounded_queue,23,i:   1,063,105 msg/sec
+   tbb::concurrent_bounded_queue,24,s:   1,034,391 msg/sec
+   tbb::concurrent_bounded_queue,24,i:   1,134,641 msg/sec
+   tbb::concurrent_bounded_queue,25,s:     919,629 msg/sec
+   tbb::concurrent_bounded_queue,25,i:   1,034,531 msg/sec
+   tbb::concurrent_bounded_queue,26,s:     828,854 msg/sec
+   tbb::concurrent_bounded_queue,26,i:   1,050,141 msg/sec
+   tbb::concurrent_bounded_queue,27,s:     802,094 msg/sec
+   tbb::concurrent_bounded_queue,27,i:   1,087,126 msg/sec
+   tbb::concurrent_bounded_queue,28,s:     757,896 msg/sec
+   tbb::concurrent_bounded_queue,28,i:   1,001,942 msg/sec
+     xenium::michael_scott_queue, 1,s:   6,087,911 msg/sec
+     xenium::michael_scott_queue, 1,i:   5,973,660 msg/sec
+     xenium::michael_scott_queue, 2,s:   4,839,244 msg/sec
+     xenium::michael_scott_queue, 2,i:   4,943,268 msg/sec
+     xenium::michael_scott_queue, 3,s:   3,900,562 msg/sec
+     xenium::michael_scott_queue, 3,i:   3,844,148 msg/sec
+     xenium::michael_scott_queue, 4,s:   3,351,319 msg/sec
+     xenium::michael_scott_queue, 4,i:   3,283,584 msg/sec
+     xenium::michael_scott_queue, 5,s:   2,995,125 msg/sec
+     xenium::michael_scott_queue, 5,i:   2,966,782 msg/sec
+     xenium::michael_scott_queue, 6,s:   2,654,470 msg/sec
+     xenium::michael_scott_queue, 6,i:   2,631,512 msg/sec
+     xenium::michael_scott_queue, 7,s:   2,416,360 msg/sec
+     xenium::michael_scott_queue, 7,i:   2,412,721 msg/sec
+     xenium::michael_scott_queue, 8,s:   1,338,731 msg/sec
+xenium::michael_scott_queue: producers: 8: consumer 1 received too few messages: 0.03% of expected.
+     xenium::michael_scott_queue, 8,i:   2,093,123 msg/sec
+     xenium::michael_scott_queue, 9,s:     957,648 msg/sec
+xenium::michael_scott_queue: producers: 9: consumer 6 received too few messages: 0.06% of expected.
+xenium::michael_scott_queue: producers: 9: consumer 0 received too few messages: 0.07% of expected.
+     xenium::michael_scott_queue, 9,i:   1,475,539 msg/sec
+     xenium::michael_scott_queue,10,s:     874,576 msg/sec
+     xenium::michael_scott_queue,10,i:   1,097,559 msg/sec
+     xenium::michael_scott_queue,11,s:     851,316 msg/sec
+     xenium::michael_scott_queue,11,i:     858,944 msg/sec
+     xenium::michael_scott_queue,12,s:     859,542 msg/sec
+     xenium::michael_scott_queue,12,i:     781,581 msg/sec
+     xenium::michael_scott_queue,13,s:     867,708 msg/sec
+     xenium::michael_scott_queue,13,i:     756,735 msg/sec
+     xenium::michael_scott_queue,14,s:     882,615 msg/sec
+     xenium::michael_scott_queue,14,i:     754,595 msg/sec
+     xenium::michael_scott_queue,15,s:     914,757 msg/sec
+     xenium::michael_scott_queue,15,i:     790,262 msg/sec
+     xenium::michael_scott_queue,16,s:     919,740 msg/sec
+     xenium::michael_scott_queue,16,i:     775,181 msg/sec
+     xenium::michael_scott_queue,17,s:     900,991 msg/sec
+     xenium::michael_scott_queue,17,i:     763,415 msg/sec
+     xenium::michael_scott_queue,18,s:     855,615 msg/sec
+     xenium::michael_scott_queue,18,i:     783,522 msg/sec
+     xenium::michael_scott_queue,19,s:     792,582 msg/sec
+     xenium::michael_scott_queue,19,i:     807,000 msg/sec
+     xenium::michael_scott_queue,20,s:     715,598 msg/sec
+     xenium::michael_scott_queue,20,i:     797,604 msg/sec
+     xenium::michael_scott_queue,21,s:     752,375 msg/sec
+     xenium::michael_scott_queue,21,i:     784,862 msg/sec
+     xenium::michael_scott_queue,22,s:     711,311 msg/sec
+     xenium::michael_scott_queue,22,i:     808,771 msg/sec
+     xenium::michael_scott_queue,23,s:     681,410 msg/sec
+     xenium::michael_scott_queue,23,i:     809,788 msg/sec
+     xenium::michael_scott_queue,24,s:     624,802 msg/sec
+     xenium::michael_scott_queue,24,i:     822,990 msg/sec
+     xenium::michael_scott_queue,25,s:     635,117 msg/sec
+     xenium::michael_scott_queue,25,i:     819,132 msg/sec
+     xenium::michael_scott_queue,26,s:     592,770 msg/sec
+     xenium::michael_scott_queue,26,i:     819,099 msg/sec
+xenium::michael_scott_queue: producers: 27: consumer 0 received too few messages: 0.07% of expected.
+     xenium::michael_scott_queue,27,s:     550,901 msg/sec
+     xenium::michael_scott_queue,27,i:     820,302 msg/sec
+     xenium::michael_scott_queue,28,s:     560,111 msg/sec
+     xenium::michael_scott_queue,28,i:     811,424 msg/sec
+         xenium::ramalhete_queue, 1,s:   9,567,120 msg/sec
+         xenium::ramalhete_queue, 1,i:   9,619,168 msg/sec
+         xenium::ramalhete_queue, 2,s:  15,444,315 msg/sec
+         xenium::ramalhete_queue, 2,i:  15,050,621 msg/sec
+         xenium::ramalhete_queue, 3,s:  17,279,594 msg/sec
+         xenium::ramalhete_queue, 3,i:  17,121,031 msg/sec
+         xenium::ramalhete_queue, 4,s:  18,001,312 msg/sec
+         xenium::ramalhete_queue, 4,i:  17,566,641 msg/sec
+         xenium::ramalhete_queue, 5,s:  18,108,353 msg/sec
+         xenium::ramalhete_queue, 5,i:  17,789,638 msg/sec
+         xenium::ramalhete_queue, 6,s:  17,764,211 msg/sec
+         xenium::ramalhete_queue, 6,i:  17,466,043 msg/sec
+         xenium::ramalhete_queue, 7,s:  17,690,124 msg/sec
+         xenium::ramalhete_queue, 7,i:  17,417,677 msg/sec
+         xenium::ramalhete_queue, 8,s:   8,081,813 msg/sec
+         xenium::ramalhete_queue, 8,i:  12,095,927 msg/sec
+         xenium::ramalhete_queue, 9,s:   7,574,517 msg/sec
+         xenium::ramalhete_queue, 9,i:  11,374,828 msg/sec
+         xenium::ramalhete_queue,10,s:   7,254,124 msg/sec
+         xenium::ramalhete_queue,10,i:   8,472,110 msg/sec
+         xenium::ramalhete_queue,11,s:   4,033,612 msg/sec
+         xenium::ramalhete_queue,11,i:   8,149,429 msg/sec
+         xenium::ramalhete_queue,12,s:   2,885,247 msg/sec
+         xenium::ramalhete_queue,12,i:   7,637,845 msg/sec
+         xenium::ramalhete_queue,13,s:   9,003,628 msg/sec
+         xenium::ramalhete_queue,13,i:   7,624,103 msg/sec
+         xenium::ramalhete_queue,14,s:  16,436,702 msg/sec
+         xenium::ramalhete_queue,14,i:   7,578,451 msg/sec
+         xenium::ramalhete_queue,15,s:   8,977,087 msg/sec
+         xenium::ramalhete_queue,15,i:   8,052,175 msg/sec
+         xenium::ramalhete_queue,16,s:   8,142,653 msg/sec
+         xenium::ramalhete_queue,16,i:   8,543,981 msg/sec
+         xenium::ramalhete_queue,17,s:   7,631,201 msg/sec
+         xenium::ramalhete_queue,17,i:   8,731,522 msg/sec
+         xenium::ramalhete_queue,18,s:   7,264,692 msg/sec
+         xenium::ramalhete_queue,18,i:   9,256,970 msg/sec
+         xenium::ramalhete_queue,19,s:   7,086,574 msg/sec
+         xenium::ramalhete_queue,19,i:   9,702,664 msg/sec
+         xenium::ramalhete_queue,20,s:   7,437,731 msg/sec
+         xenium::ramalhete_queue,20,i:   9,872,264 msg/sec
+         xenium::ramalhete_queue,21,s:   7,643,080 msg/sec
+         xenium::ramalhete_queue,21,i:  10,232,115 msg/sec
+         xenium::ramalhete_queue,22,s:   6,765,281 msg/sec
+         xenium::ramalhete_queue,22,i:  10,917,282 msg/sec
+         xenium::ramalhete_queue,23,s:   6,062,503 msg/sec
+         xenium::ramalhete_queue,23,i:  11,357,220 msg/sec
+         xenium::ramalhete_queue,24,s:   5,784,848 msg/sec
+         xenium::ramalhete_queue,24,i:  11,837,857 msg/sec
+         xenium::ramalhete_queue,25,s:   5,575,124 msg/sec
+         xenium::ramalhete_queue,25,i:  12,200,564 msg/sec
+         xenium::ramalhete_queue,26,s:   5,449,886 msg/sec
+         xenium::ramalhete_queue,26,i:  12,756,375 msg/sec
+         xenium::ramalhete_queue,27,s:   5,428,683 msg/sec
+         xenium::ramalhete_queue,27,i:  13,079,069 msg/sec
+         xenium::ramalhete_queue,28,s:   5,300,291 msg/sec
+         xenium::ramalhete_queue,28,i:  13,643,916 msg/sec
+    xenium::vyukov_bounded_queue, 1,s:  77,693,727 msg/sec
+    xenium::vyukov_bounded_queue, 1,i:  57,935,240 msg/sec
+    xenium::vyukov_bounded_queue, 2,s:   6,351,933 msg/sec
+    xenium::vyukov_bounded_queue, 2,i:   6,393,902 msg/sec
+    xenium::vyukov_bounded_queue, 3,s:   4,721,665 msg/sec
+    xenium::vyukov_bounded_queue, 3,i:   4,665,999 msg/sec
+    xenium::vyukov_bounded_queue, 4,s:   4,404,695 msg/sec
+    xenium::vyukov_bounded_queue, 4,i:   4,396,911 msg/sec
+    xenium::vyukov_bounded_queue, 5,s:   4,768,806 msg/sec
+    xenium::vyukov_bounded_queue, 5,i:   4,873,888 msg/sec
+    xenium::vyukov_bounded_queue, 6,s:   4,939,120 msg/sec
+    xenium::vyukov_bounded_queue, 6,i:   4,461,586 msg/sec
+    xenium::vyukov_bounded_queue, 7,s:   4,306,018 msg/sec
+    xenium::vyukov_bounded_queue, 7,i:   3,818,955 msg/sec
+    xenium::vyukov_bounded_queue, 8,s:   1,908,903 msg/sec
+xenium::vyukov_bounded_queue: producers: 8: consumer 4 received too few messages: 0.06% of expected.
+xenium::vyukov_bounded_queue: producers: 8: consumer 2 received too few messages: 0.07% of expected.
+    xenium::vyukov_bounded_queue, 8,i:   3,475,570 msg/sec
+    xenium::vyukov_bounded_queue, 9,s:   1,547,119 msg/sec
+    xenium::vyukov_bounded_queue, 9,i:   2,063,884 msg/sec
+    xenium::vyukov_bounded_queue,10,s:   1,363,881 msg/sec
+    xenium::vyukov_bounded_queue,10,i:   2,274,182 msg/sec
+    xenium::vyukov_bounded_queue,11,s:   1,288,127 msg/sec
+    xenium::vyukov_bounded_queue,11,i:   1,666,304 msg/sec
+    xenium::vyukov_bounded_queue,12,s:   1,798,928 msg/sec
+    xenium::vyukov_bounded_queue,12,i:   1,429,573 msg/sec
+    xenium::vyukov_bounded_queue,13,s:   1,319,297 msg/sec
+    xenium::vyukov_bounded_queue,13,i:   1,238,154 msg/sec
+    xenium::vyukov_bounded_queue,14,s:   1,098,229 msg/sec
+    xenium::vyukov_bounded_queue,14,i:   1,308,885 msg/sec
+    xenium::vyukov_bounded_queue,15,s:   1,126,230 msg/sec
+    xenium::vyukov_bounded_queue,15,i:   1,284,529 msg/sec
+    xenium::vyukov_bounded_queue,16,s:   1,216,249 msg/sec
+    xenium::vyukov_bounded_queue,16,i:   1,306,070 msg/sec
+    xenium::vyukov_bounded_queue,17,s:   1,352,608 msg/sec
+    xenium::vyukov_bounded_queue,17,i:   1,296,785 msg/sec
+    xenium::vyukov_bounded_queue,18,s:   1,318,919 msg/sec
+    xenium::vyukov_bounded_queue,18,i:   1,323,451 msg/sec
+    xenium::vyukov_bounded_queue,19,s:   1,221,440 msg/sec
+    xenium::vyukov_bounded_queue,19,i:   1,338,820 msg/sec
+    xenium::vyukov_bounded_queue,20,s:   1,210,423 msg/sec
+    xenium::vyukov_bounded_queue,20,i:   1,354,683 msg/sec
+    xenium::vyukov_bounded_queue,21,s:   1,129,205 msg/sec
+    xenium::vyukov_bounded_queue,21,i:   1,390,226 msg/sec
+    xenium::vyukov_bounded_queue,22,s:   1,164,455 msg/sec
+    xenium::vyukov_bounded_queue,22,i:   1,386,801 msg/sec
+    xenium::vyukov_bounded_queue,23,s:   1,146,081 msg/sec
+    xenium::vyukov_bounded_queue,23,i:   1,385,629 msg/sec
+    xenium::vyukov_bounded_queue,24,s:   1,040,731 msg/sec
+    xenium::vyukov_bounded_queue,24,i:   1,394,698 msg/sec
+xenium::vyukov_bounded_queue: producers: 25: consumer 21 received too few messages: 0.10% of expected.
+    xenium::vyukov_bounded_queue,25,s:     952,623 msg/sec
+    xenium::vyukov_bounded_queue,25,i:   1,439,827 msg/sec
+xenium::vyukov_bounded_queue: producers: 26: consumer 17 received too few messages: 0.09% of expected.
+    xenium::vyukov_bounded_queue,26,s:     803,291 msg/sec
+    xenium::vyukov_bounded_queue,26,i:   1,432,610 msg/sec
+xenium::vyukov_bounded_queue: producers: 27: consumer 17 received too few messages: 0.08% of expected.
+    xenium::vyukov_bounded_queue,27,s:     743,491 msg/sec
+    xenium::vyukov_bounded_queue,27,i:   1,457,092 msg/sec
+    xenium::vyukov_bounded_queue,28,s:     710,389 msg/sec
+    xenium::vyukov_bounded_queue,28,i:   1,452,180 msg/sec
+                     AtomicQueue, 1,s:  79,772,865 msg/sec
+                     AtomicQueue, 1,i:  77,217,926 msg/sec
+                     AtomicQueue, 2,s:   5,228,301 msg/sec
+                     AtomicQueue, 2,i:   5,322,278 msg/sec
+                     AtomicQueue, 3,s:   4,041,654 msg/sec
+                     AtomicQueue, 3,i:   4,152,137 msg/sec
+                     AtomicQueue, 4,s:   3,290,899 msg/sec
+                     AtomicQueue, 4,i:   3,371,436 msg/sec
+                     AtomicQueue, 5,s:   3,088,270 msg/sec
+                     AtomicQueue, 5,i:   3,032,945 msg/sec
+                     AtomicQueue, 6,s:   2,632,802 msg/sec
+                     AtomicQueue, 6,i:   2,665,903 msg/sec
+                     AtomicQueue, 7,s:   2,323,482 msg/sec
+                     AtomicQueue, 7,i:   2,361,146 msg/sec
+                     AtomicQueue, 8,s:     908,494 msg/sec
+                     AtomicQueue, 8,i:   2,207,479 msg/sec
+                     AtomicQueue, 9,s:     752,080 msg/sec
+                     AtomicQueue, 9,i:   1,641,588 msg/sec
+                     AtomicQueue,10,s:     640,224 msg/sec
+                     AtomicQueue,10,i:   1,205,194 msg/sec
+                     AtomicQueue,11,s:     574,183 msg/sec
+                     AtomicQueue,11,i:     889,738 msg/sec
+                     AtomicQueue,12,s:     550,395 msg/sec
+                     AtomicQueue,12,i:     592,877 msg/sec
+                     AtomicQueue,13,s:     538,031 msg/sec
+                     AtomicQueue,13,i:     517,048 msg/sec
+                     AtomicQueue,14,s:     471,733 msg/sec
+                     AtomicQueue,14,i:     482,650 msg/sec
+                     AtomicQueue,15,s:     508,808 msg/sec
+                     AtomicQueue,15,i:     498,364 msg/sec
+                     AtomicQueue,16,s:     533,182 msg/sec
+                     AtomicQueue,16,i:     506,302 msg/sec
+                     AtomicQueue,17,s:     558,629 msg/sec
+                     AtomicQueue,17,i:     492,533 msg/sec
+                     AtomicQueue,18,s:     567,271 msg/sec
+                     AtomicQueue,18,i:     500,401 msg/sec
+                     AtomicQueue,19,s:     559,687 msg/sec
+                     AtomicQueue,19,i:     524,712 msg/sec
+                     AtomicQueue,20,s:     544,831 msg/sec
+                     AtomicQueue,20,i:     512,759 msg/sec
+                     AtomicQueue,21,s:     521,285 msg/sec
+                     AtomicQueue,21,i:     511,789 msg/sec
+                     AtomicQueue,22,s:     506,268 msg/sec
+                     AtomicQueue,22,i:     532,692 msg/sec
+                     AtomicQueue,23,s:     518,073 msg/sec
+                     AtomicQueue,23,i:     537,241 msg/sec
+                     AtomicQueue,24,s:     462,993 msg/sec
+                     AtomicQueue,24,i:     507,631 msg/sec
+                     AtomicQueue,25,s:     438,405 msg/sec
+                     AtomicQueue,25,i:     523,575 msg/sec
+                     AtomicQueue,26,s:     421,278 msg/sec
+                     AtomicQueue,26,i:     501,521 msg/sec
+                     AtomicQueue,27,s:     437,904 msg/sec
+                     AtomicQueue,27,i:     482,943 msg/sec
+                     AtomicQueue,28,s:     399,149 msg/sec
+                     AtomicQueue,28,i:     477,047 msg/sec
+                    AtomicQueueB, 1,s:  47,438,573 msg/sec
+                    AtomicQueueB, 1,i:  36,715,771 msg/sec
+                    AtomicQueueB, 2,s:   5,365,020 msg/sec
+                    AtomicQueueB, 2,i:   5,376,771 msg/sec
+                    AtomicQueueB, 3,s:   3,960,556 msg/sec
+                    AtomicQueueB, 3,i:   4,112,612 msg/sec
+                    AtomicQueueB, 4,s:   3,246,590 msg/sec
+                    AtomicQueueB, 4,i:   3,314,863 msg/sec
+                    AtomicQueueB, 5,s:   2,969,057 msg/sec
+                    AtomicQueueB, 5,i:   3,017,942 msg/sec
+                    AtomicQueueB, 6,s:   2,602,342 msg/sec
+                    AtomicQueueB, 6,i:   2,652,390 msg/sec
+                    AtomicQueueB, 7,s:   2,308,771 msg/sec
+                    AtomicQueueB, 7,i:   2,348,205 msg/sec
+                    AtomicQueueB, 8,s:     918,766 msg/sec
+                    AtomicQueueB, 8,i:   2,201,598 msg/sec
+                    AtomicQueueB, 9,s:     758,205 msg/sec
+AtomicQueueB: producers: 9: consumer 6 received too few messages: 0.06% of expected.
+AtomicQueueB: producers: 9: consumer 0 received too few messages: 0.06% of expected.
+                    AtomicQueueB, 9,i:   1,633,309 msg/sec
+                    AtomicQueueB,10,s:     649,014 msg/sec
+                    AtomicQueueB,10,i:   1,195,059 msg/sec
+                    AtomicQueueB,11,s:     589,662 msg/sec
+                    AtomicQueueB,11,i:     879,485 msg/sec
+                    AtomicQueueB,12,s:     575,181 msg/sec
+                    AtomicQueueB,12,i:     621,402 msg/sec
+                    AtomicQueueB,13,s:     542,750 msg/sec
+                    AtomicQueueB,13,i:     502,794 msg/sec
+                    AtomicQueueB,14,s:     472,781 msg/sec
+                    AtomicQueueB,14,i:     468,631 msg/sec
+                    AtomicQueueB,15,s:     505,662 msg/sec
+                    AtomicQueueB,15,i:     499,555 msg/sec
+                    AtomicQueueB,16,s:     529,470 msg/sec
+                    AtomicQueueB,16,i:     492,589 msg/sec
+                    AtomicQueueB,17,s:     550,989 msg/sec
+                    AtomicQueueB,17,i:     484,494 msg/sec
+                    AtomicQueueB,18,s:     548,113 msg/sec
+                    AtomicQueueB,18,i:     504,459 msg/sec
+                    AtomicQueueB,19,s:     536,477 msg/sec
+                    AtomicQueueB,19,i:     498,815 msg/sec
+                    AtomicQueueB,20,s:     546,760 msg/sec
+                    AtomicQueueB,20,i:     501,568 msg/sec
+                    AtomicQueueB,21,s:     499,480 msg/sec
+                    AtomicQueueB,21,i:     524,874 msg/sec
+                    AtomicQueueB,22,s:     505,888 msg/sec
+                    AtomicQueueB,22,i:     516,875 msg/sec
+                    AtomicQueueB,23,s:     513,906 msg/sec
+                    AtomicQueueB,23,i:     514,174 msg/sec
+                    AtomicQueueB,24,s:     483,252 msg/sec
+                    AtomicQueueB,24,i:     525,254 msg/sec
+                    AtomicQueueB,25,s:     451,654 msg/sec
+                    AtomicQueueB,25,i:     506,582 msg/sec
+                    AtomicQueueB,26,s:     420,500 msg/sec
+                    AtomicQueueB,26,i:     505,109 msg/sec
+                    AtomicQueueB,27,s:     426,964 msg/sec
+                    AtomicQueueB,27,i:     482,598 msg/sec
+                    AtomicQueueB,28,s:     414,367 msg/sec
+                    AtomicQueueB,28,i:     478,045 msg/sec
+             OptimistAtomicQueue, 1,s: 490,054,624 msg/sec
+             OptimistAtomicQueue, 1,i: 484,095,327 msg/sec
+             OptimistAtomicQueue, 2,s:  13,720,515 msg/sec
+             OptimistAtomicQueue, 2,i:  13,769,344 msg/sec
+             OptimistAtomicQueue, 3,s:  14,601,848 msg/sec
+             OptimistAtomicQueue, 3,i:  14,715,831 msg/sec
+             OptimistAtomicQueue, 4,s:  15,384,078 msg/sec
+             OptimistAtomicQueue, 4,i:  15,464,966 msg/sec
+             OptimistAtomicQueue, 5,s:  16,770,529 msg/sec
+             OptimistAtomicQueue, 5,i:  17,059,718 msg/sec
+             OptimistAtomicQueue, 6,s:  17,237,155 msg/sec
+             OptimistAtomicQueue, 6,i:  17,537,609 msg/sec
+             OptimistAtomicQueue, 7,s:  17,569,838 msg/sec
+             OptimistAtomicQueue, 7,i:  17,760,428 msg/sec
+             OptimistAtomicQueue, 8,s:   7,534,351 msg/sec
+             OptimistAtomicQueue, 8,i:  11,499,230 msg/sec
+             OptimistAtomicQueue, 9,s:   6,675,629 msg/sec
+             OptimistAtomicQueue, 9,i:   7,806,498 msg/sec
+             OptimistAtomicQueue,10,s:   6,241,334 msg/sec
+             OptimistAtomicQueue,10,i:   6,834,659 msg/sec
+             OptimistAtomicQueue,11,s:   5,914,049 msg/sec
+             OptimistAtomicQueue,11,i:   6,181,994 msg/sec
+             OptimistAtomicQueue,12,s:   5,199,936 msg/sec
+             OptimistAtomicQueue,12,i:   5,909,534 msg/sec
+             OptimistAtomicQueue,13,s:   4,589,785 msg/sec
+             OptimistAtomicQueue,13,i:   6,147,249 msg/sec
+             OptimistAtomicQueue,14,s:   3,878,266 msg/sec
+             OptimistAtomicQueue,14,i:   6,104,766 msg/sec
+             OptimistAtomicQueue,15,s:   4,784,026 msg/sec
+             OptimistAtomicQueue,15,i:   6,449,264 msg/sec
+             OptimistAtomicQueue,16,s:   4,920,347 msg/sec
+             OptimistAtomicQueue,16,i:   6,435,966 msg/sec
+             OptimistAtomicQueue,17,s:   5,111,870 msg/sec
+             OptimistAtomicQueue,17,i:   6,615,520 msg/sec
+             OptimistAtomicQueue,18,s:   5,432,958 msg/sec
+             OptimistAtomicQueue,18,i:   6,731,241 msg/sec
+             OptimistAtomicQueue,19,s:   5,491,359 msg/sec
+             OptimistAtomicQueue,19,i:   6,858,386 msg/sec
+             OptimistAtomicQueue,20,s:   6,286,582 msg/sec
+             OptimistAtomicQueue,20,i:   6,960,726 msg/sec
+             OptimistAtomicQueue,21,s:   6,682,416 msg/sec
+             OptimistAtomicQueue,21,i:   7,092,639 msg/sec
+             OptimistAtomicQueue,22,s:   6,418,524 msg/sec
+             OptimistAtomicQueue,22,i:   7,401,114 msg/sec
+             OptimistAtomicQueue,23,s:   6,376,475 msg/sec
+             OptimistAtomicQueue,23,i:   7,683,225 msg/sec
+             OptimistAtomicQueue,24,s:   6,360,283 msg/sec
+             OptimistAtomicQueue,24,i:   8,006,488 msg/sec
+             OptimistAtomicQueue,25,s:   6,197,136 msg/sec
+             OptimistAtomicQueue,25,i:   8,313,302 msg/sec
+             OptimistAtomicQueue,26,s:   6,244,154 msg/sec
+             OptimistAtomicQueue,26,i:   8,619,479 msg/sec
+OptimistAtomicQueue: producers: 27: consumer 11 received too few messages: 0.09% of expected.
+OptimistAtomicQueue: producers: 27: consumer 24 received too few messages: 0.08% of expected.
+OptimistAtomicQueue: producers: 27: consumer 7 received too few messages: 0.10% of expected.
+             OptimistAtomicQueue,27,s:   6,866,018 msg/sec
+             OptimistAtomicQueue,27,i:   8,939,372 msg/sec
+             OptimistAtomicQueue,28,s:   5,565,018 msg/sec
+             OptimistAtomicQueue,28,i:   9,232,001 msg/sec
+            OptimistAtomicQueueB, 1,s: 239,359,767 msg/sec
+            OptimistAtomicQueueB, 1,i:  80,413,426 msg/sec
+            OptimistAtomicQueueB, 2,s:  13,821,801 msg/sec
+            OptimistAtomicQueueB, 2,i:  13,835,022 msg/sec
+            OptimistAtomicQueueB, 3,s:  14,541,806 msg/sec
+            OptimistAtomicQueueB, 3,i:  14,648,662 msg/sec
+            OptimistAtomicQueueB, 4,s:  15,259,340 msg/sec
+            OptimistAtomicQueueB, 4,i:  15,385,569 msg/sec
+            OptimistAtomicQueueB, 5,s:  16,641,349 msg/sec
+            OptimistAtomicQueueB, 5,i:  16,917,226 msg/sec
+            OptimistAtomicQueueB, 6,s:  17,112,059 msg/sec
+            OptimistAtomicQueueB, 6,i:  17,415,295 msg/sec
+            OptimistAtomicQueueB, 7,s:  17,479,018 msg/sec
+            OptimistAtomicQueueB, 7,i:  17,632,618 msg/sec
+            OptimistAtomicQueueB, 8,s:   7,390,170 msg/sec
+            OptimistAtomicQueueB, 8,i:  11,741,384 msg/sec
+            OptimistAtomicQueueB, 9,s:   6,572,124 msg/sec
+            OptimistAtomicQueueB, 9,i:   7,500,283 msg/sec
+            OptimistAtomicQueueB,10,s:   6,313,129 msg/sec
+            OptimistAtomicQueueB,10,i:   6,104,042 msg/sec
+            OptimistAtomicQueueB,11,s:   5,859,540 msg/sec
+            OptimistAtomicQueueB,11,i:   6,225,458 msg/sec
+            OptimistAtomicQueueB,12,s:   5,288,305 msg/sec
+            OptimistAtomicQueueB,12,i:   5,923,237 msg/sec
+            OptimistAtomicQueueB,13,s:   4,584,836 msg/sec
+            OptimistAtomicQueueB,13,i:   5,996,519 msg/sec
+            OptimistAtomicQueueB,14,s:   3,847,023 msg/sec
+            OptimistAtomicQueueB,14,i:   6,529,716 msg/sec
+            OptimistAtomicQueueB,15,s:   4,707,856 msg/sec
+            OptimistAtomicQueueB,15,i:   6,206,118 msg/sec
+            OptimistAtomicQueueB,16,s:   4,879,939 msg/sec
+            OptimistAtomicQueueB,16,i:   6,583,111 msg/sec
+            OptimistAtomicQueueB,17,s:   5,119,063 msg/sec
+            OptimistAtomicQueueB,17,i:   6,535,731 msg/sec
+            OptimistAtomicQueueB,18,s:   5,446,519 msg/sec
+            OptimistAtomicQueueB,18,i:   6,701,125 msg/sec
+            OptimistAtomicQueueB,19,s:   5,549,130 msg/sec
+            OptimistAtomicQueueB,19,i:   6,805,469 msg/sec
+            OptimistAtomicQueueB,20,s:   6,164,500 msg/sec
+            OptimistAtomicQueueB,20,i:   6,975,990 msg/sec
+            OptimistAtomicQueueB,21,s:   6,417,871 msg/sec
+            OptimistAtomicQueueB,21,i:   7,071,665 msg/sec
+            OptimistAtomicQueueB,22,s:   6,212,319 msg/sec
+            OptimistAtomicQueueB,22,i:   7,399,107 msg/sec
+            OptimistAtomicQueueB,23,s:   6,119,000 msg/sec
+            OptimistAtomicQueueB,23,i:   7,690,375 msg/sec
+            OptimistAtomicQueueB,24,s:   5,897,361 msg/sec
+            OptimistAtomicQueueB,24,i:   7,996,467 msg/sec
+            OptimistAtomicQueueB,25,s:   5,787,206 msg/sec
+            OptimistAtomicQueueB,25,i:   8,293,432 msg/sec
+            OptimistAtomicQueueB,26,s:   6,110,304 msg/sec
+            OptimistAtomicQueueB,26,i:   8,622,487 msg/sec
+            OptimistAtomicQueueB,27,s:   6,550,818 msg/sec
+            OptimistAtomicQueueB,27,i:   8,938,106 msg/sec
+            OptimistAtomicQueueB,28,s:   5,473,162 msg/sec
+            OptimistAtomicQueueB,28,i:   9,241,486 msg/sec
+                    AtomicQueue2, 1,s:  23,820,635 msg/sec
+                    AtomicQueue2, 1,i:  22,969,183 msg/sec
+                    AtomicQueue2, 2,s:   5,026,705 msg/sec
+                    AtomicQueue2, 2,i:   5,077,014 msg/sec
+                    AtomicQueue2, 3,s:   3,930,905 msg/sec
+                    AtomicQueue2, 3,i:   4,044,969 msg/sec
+                    AtomicQueue2, 4,s:   3,235,081 msg/sec
+                    AtomicQueue2, 4,i:   3,300,821 msg/sec
+                    AtomicQueue2, 5,s:   2,972,579 msg/sec
+                    AtomicQueue2, 5,i:   2,996,009 msg/sec
+                    AtomicQueue2, 6,s:   2,606,889 msg/sec
+                    AtomicQueue2, 6,i:   2,653,808 msg/sec
+                    AtomicQueue2, 7,s:   2,310,335 msg/sec
+                    AtomicQueue2, 7,i:   2,350,312 msg/sec
+                    AtomicQueue2, 8,s:     883,952 msg/sec
+                    AtomicQueue2, 8,i:   2,164,039 msg/sec
+                    AtomicQueue2, 9,s:     729,613 msg/sec
+                    AtomicQueue2, 9,i:   1,632,855 msg/sec
+                    AtomicQueue2,10,s:     627,970 msg/sec
+                    AtomicQueue2,10,i:   1,213,308 msg/sec
+                    AtomicQueue2,11,s:     571,190 msg/sec
+                    AtomicQueue2,11,i:     773,100 msg/sec
+                    AtomicQueue2,12,s:     552,257 msg/sec
+                    AtomicQueue2,12,i:     674,055 msg/sec
+                    AtomicQueue2,13,s:     539,411 msg/sec
+                    AtomicQueue2,13,i:     518,344 msg/sec
+                    AtomicQueue2,14,s:     467,152 msg/sec
+                    AtomicQueue2,14,i:     478,024 msg/sec
+                    AtomicQueue2,15,s:     504,016 msg/sec
+                    AtomicQueue2,15,i:     490,031 msg/sec
+                    AtomicQueue2,16,s:     531,799 msg/sec
+                    AtomicQueue2,16,i:     486,517 msg/sec
+                    AtomicQueue2,17,s:     543,079 msg/sec
+                    AtomicQueue2,17,i:     496,588 msg/sec
+                    AtomicQueue2,18,s:     547,615 msg/sec
+                    AtomicQueue2,18,i:     491,143 msg/sec
+                    AtomicQueue2,19,s:     542,636 msg/sec
+                    AtomicQueue2,19,i:     541,999 msg/sec
+                    AtomicQueue2,20,s:     521,610 msg/sec
+                    AtomicQueue2,20,i:     547,004 msg/sec
+                    AtomicQueue2,21,s:     499,529 msg/sec
+                    AtomicQueue2,21,i:     519,443 msg/sec
+                    AtomicQueue2,22,s:     509,717 msg/sec
+                    AtomicQueue2,22,i:     523,333 msg/sec
+                    AtomicQueue2,23,s:     470,999 msg/sec
+                    AtomicQueue2,23,i:     529,548 msg/sec
+                    AtomicQueue2,24,s:     480,228 msg/sec
+                    AtomicQueue2,24,i:     522,050 msg/sec
+                    AtomicQueue2,25,s:     429,897 msg/sec
+                    AtomicQueue2,25,i:     501,764 msg/sec
+                    AtomicQueue2,26,s:     422,101 msg/sec
+                    AtomicQueue2,26,i:     497,520 msg/sec
+                    AtomicQueue2,27,s:     422,020 msg/sec
+                    AtomicQueue2,27,i:     483,837 msg/sec
+                    AtomicQueue2,28,s:     429,190 msg/sec
+                    AtomicQueue2,28,i:     476,448 msg/sec
+                   AtomicQueueB2, 1,s:  17,215,273 msg/sec
+                   AtomicQueueB2, 1,i:  17,210,621 msg/sec
+                   AtomicQueueB2, 2,s:   5,094,130 msg/sec
+                   AtomicQueueB2, 2,i:   5,175,396 msg/sec
+                   AtomicQueueB2, 3,s:   3,922,155 msg/sec
+                   AtomicQueueB2, 3,i:   4,052,567 msg/sec
+                   AtomicQueueB2, 4,s:   3,215,549 msg/sec
+                   AtomicQueueB2, 4,i:   3,290,586 msg/sec
+                   AtomicQueueB2, 5,s:   2,978,908 msg/sec
+                   AtomicQueueB2, 5,i:   3,006,456 msg/sec
+                   AtomicQueueB2, 6,s:   2,632,036 msg/sec
+                   AtomicQueueB2, 6,i:   2,672,123 msg/sec
+                   AtomicQueueB2, 7,s:   2,315,208 msg/sec
+                   AtomicQueueB2, 7,i:   2,361,934 msg/sec
+                   AtomicQueueB2, 8,s:     890,429 msg/sec
+                   AtomicQueueB2, 8,i:   2,133,729 msg/sec
+                   AtomicQueueB2, 9,s:     724,498 msg/sec
+                   AtomicQueueB2, 9,i:   1,589,044 msg/sec
+                   AtomicQueueB2,10,s:     632,408 msg/sec
+                   AtomicQueueB2,10,i:   1,194,042 msg/sec
+                   AtomicQueueB2,11,s:     572,357 msg/sec
+                   AtomicQueueB2,11,i:     895,109 msg/sec
+                   AtomicQueueB2,12,s:     549,668 msg/sec
+                   AtomicQueueB2,12,i:     670,994 msg/sec
+                   AtomicQueueB2,13,s:     536,501 msg/sec
+                   AtomicQueueB2,13,i:     502,503 msg/sec
+                   AtomicQueueB2,14,s:     466,850 msg/sec
+                   AtomicQueueB2,14,i:     460,185 msg/sec
+                   AtomicQueueB2,15,s:     503,173 msg/sec
+                   AtomicQueueB2,15,i:     493,614 msg/sec
+                   AtomicQueueB2,16,s:     531,524 msg/sec
+                   AtomicQueueB2,16,i:     482,348 msg/sec
+                   AtomicQueueB2,17,s:     538,869 msg/sec
+                   AtomicQueueB2,17,i:     490,159 msg/sec
+                   AtomicQueueB2,18,s:     546,701 msg/sec
+                   AtomicQueueB2,18,i:     508,125 msg/sec
+                   AtomicQueueB2,19,s:     553,294 msg/sec
+                   AtomicQueueB2,19,i:     523,688 msg/sec
+                   AtomicQueueB2,20,s:     515,627 msg/sec
+                   AtomicQueueB2,20,i:     529,239 msg/sec
+                   AtomicQueueB2,21,s:     513,581 msg/sec
+                   AtomicQueueB2,21,i:     517,527 msg/sec
+                   AtomicQueueB2,22,s:     518,339 msg/sec
+                   AtomicQueueB2,22,i:     532,753 msg/sec
+                   AtomicQueueB2,23,s:     494,051 msg/sec
+                   AtomicQueueB2,23,i:     534,986 msg/sec
+                   AtomicQueueB2,24,s:     491,424 msg/sec
+                   AtomicQueueB2,24,i:     510,188 msg/sec
+                   AtomicQueueB2,25,s:     440,980 msg/sec
+                   AtomicQueueB2,25,i:     508,473 msg/sec
+                   AtomicQueueB2,26,s:     407,891 msg/sec
+                   AtomicQueueB2,26,i:     486,349 msg/sec
+                   AtomicQueueB2,27,s:     436,592 msg/sec
+                   AtomicQueueB2,27,i:     476,802 msg/sec
+                   AtomicQueueB2,28,s:     409,361 msg/sec
+                   AtomicQueueB2,28,i:     478,694 msg/sec
+            OptimistAtomicQueue2, 1,s: 446,196,432 msg/sec
+            OptimistAtomicQueue2, 1,i:  40,201,612 msg/sec
+            OptimistAtomicQueue2, 2,s:  10,094,174 msg/sec
+            OptimistAtomicQueue2, 2,i:  10,110,329 msg/sec
+            OptimistAtomicQueue2, 3,s:  12,085,454 msg/sec
+            OptimistAtomicQueue2, 3,i:  12,080,441 msg/sec
+            OptimistAtomicQueue2, 4,s:  13,508,019 msg/sec
+            OptimistAtomicQueue2, 4,i:  13,528,834 msg/sec
+            OptimistAtomicQueue2, 5,s:  15,309,589 msg/sec
+            OptimistAtomicQueue2, 5,i:  15,468,559 msg/sec
+            OptimistAtomicQueue2, 6,s:  16,226,800 msg/sec
+            OptimistAtomicQueue2, 6,i:  16,453,961 msg/sec
+            OptimistAtomicQueue2, 7,s:  16,728,925 msg/sec
+            OptimistAtomicQueue2, 7,i:  16,943,866 msg/sec
+            OptimistAtomicQueue2, 8,s:   6,319,662 msg/sec
+            OptimistAtomicQueue2, 8,i:   8,171,789 msg/sec
+            OptimistAtomicQueue2, 9,s:   5,136,259 msg/sec
+            OptimistAtomicQueue2, 9,i:   6,530,491 msg/sec
+            OptimistAtomicQueue2,10,s:   4,791,581 msg/sec
+            OptimistAtomicQueue2,10,i:   5,880,087 msg/sec
+            OptimistAtomicQueue2,11,s:   4,724,867 msg/sec
+            OptimistAtomicQueue2,11,i:   5,433,285 msg/sec
+            OptimistAtomicQueue2,12,s:   4,771,642 msg/sec
+            OptimistAtomicQueue2,12,i:   4,869,808 msg/sec
+            OptimistAtomicQueue2,13,s:   4,341,967 msg/sec
+            OptimistAtomicQueue2,13,i:   4,918,200 msg/sec
+            OptimistAtomicQueue2,14,s:   3,987,235 msg/sec
+            OptimistAtomicQueue2,14,i:   4,722,288 msg/sec
+            OptimistAtomicQueue2,15,s:   4,579,344 msg/sec
+            OptimistAtomicQueue2,15,i:   5,054,095 msg/sec
+            OptimistAtomicQueue2,16,s:   4,963,793 msg/sec
+            OptimistAtomicQueue2,16,i:   5,373,581 msg/sec
+            OptimistAtomicQueue2,17,s:   5,331,598 msg/sec
+            OptimistAtomicQueue2,17,i:   5,692,601 msg/sec
+            OptimistAtomicQueue2,18,s:   5,481,421 msg/sec
+            OptimistAtomicQueue2,18,i:   6,043,113 msg/sec
+            OptimistAtomicQueue2,19,s:   5,534,724 msg/sec
+            OptimistAtomicQueue2,19,i:   6,332,701 msg/sec
+            OptimistAtomicQueue2,20,s:   6,281,056 msg/sec
+            OptimistAtomicQueue2,20,i:   6,646,543 msg/sec
+            OptimistAtomicQueue2,21,s:   6,372,744 msg/sec
+            OptimistAtomicQueue2,21,i:   6,939,570 msg/sec
+            OptimistAtomicQueue2,22,s:   5,645,002 msg/sec
+            OptimistAtomicQueue2,22,i:   7,274,754 msg/sec
+            OptimistAtomicQueue2,23,s:   5,913,588 msg/sec
+            OptimistAtomicQueue2,23,i:   7,560,869 msg/sec
+            OptimistAtomicQueue2,24,s:   5,483,244 msg/sec
+            OptimistAtomicQueue2,24,i:   7,923,552 msg/sec
+            OptimistAtomicQueue2,25,s:   5,593,249 msg/sec
+            OptimistAtomicQueue2,25,i:   8,236,931 msg/sec
+            OptimistAtomicQueue2,26,s:   5,698,893 msg/sec
+            OptimistAtomicQueue2,26,i:   8,565,898 msg/sec
+            OptimistAtomicQueue2,27,s:   5,748,027 msg/sec
+            OptimistAtomicQueue2,27,i:   8,878,784 msg/sec
+            OptimistAtomicQueue2,28,s:   6,950,219 msg/sec
+            OptimistAtomicQueue2,28,i:   9,228,086 msg/sec
+           OptimistAtomicQueueB2, 1,s:  18,483,689 msg/sec
+           OptimistAtomicQueueB2, 1,i:  18,514,940 msg/sec
+           OptimistAtomicQueueB2, 2,s:  10,169,071 msg/sec
+           OptimistAtomicQueueB2, 2,i:  10,103,438 msg/sec
+           OptimistAtomicQueueB2, 3,s:  11,951,116 msg/sec
+           OptimistAtomicQueueB2, 3,i:  12,040,370 msg/sec
+           OptimistAtomicQueueB2, 4,s:  13,262,983 msg/sec
+           OptimistAtomicQueueB2, 4,i:  13,296,339 msg/sec
+           OptimistAtomicQueueB2, 5,s:  15,060,880 msg/sec
+           OptimistAtomicQueueB2, 5,i:  15,209,565 msg/sec
+           OptimistAtomicQueueB2, 6,s:  15,932,102 msg/sec
+           OptimistAtomicQueueB2, 6,i:  16,172,766 msg/sec
+           OptimistAtomicQueueB2, 7,s:  16,324,971 msg/sec
+           OptimistAtomicQueueB2, 7,i:  16,556,597 msg/sec
+           OptimistAtomicQueueB2, 8,s:   6,301,104 msg/sec
+           OptimistAtomicQueueB2, 8,i:   8,119,023 msg/sec
+           OptimistAtomicQueueB2, 9,s:   5,202,266 msg/sec
+           OptimistAtomicQueueB2, 9,i:   7,389,147 msg/sec
+           OptimistAtomicQueueB2,10,s:   5,060,597 msg/sec
+           OptimistAtomicQueueB2,10,i:   5,805,180 msg/sec
+           OptimistAtomicQueueB2,11,s:   4,784,186 msg/sec
+           OptimistAtomicQueueB2,11,i:   4,900,037 msg/sec
+           OptimistAtomicQueueB2,12,s:   4,716,909 msg/sec
+           OptimistAtomicQueueB2,12,i:   5,085,442 msg/sec
+           OptimistAtomicQueueB2,13,s:   4,354,083 msg/sec
+           OptimistAtomicQueueB2,13,i:   4,731,783 msg/sec
+           OptimistAtomicQueueB2,14,s:   3,819,186 msg/sec
+           OptimistAtomicQueueB2,14,i:   4,651,880 msg/sec
+           OptimistAtomicQueueB2,15,s:   4,514,573 msg/sec
+           OptimistAtomicQueueB2,15,i:   4,988,294 msg/sec
+           OptimistAtomicQueueB2,16,s:   5,117,055 msg/sec
+           OptimistAtomicQueueB2,16,i:   5,318,373 msg/sec
+           OptimistAtomicQueueB2,17,s:   5,187,389 msg/sec
+           OptimistAtomicQueueB2,17,i:   5,669,221 msg/sec
+           OptimistAtomicQueueB2,18,s:   5,484,858 msg/sec
+           OptimistAtomicQueueB2,18,i:   5,917,342 msg/sec
+           OptimistAtomicQueueB2,19,s:   5,750,173 msg/sec
+           OptimistAtomicQueueB2,19,i:   6,403,314 msg/sec
+           OptimistAtomicQueueB2,20,s:   6,173,457 msg/sec
+           OptimistAtomicQueueB2,20,i:   6,561,965 msg/sec
+           OptimistAtomicQueueB2,21,s:   6,254,794 msg/sec
+           OptimistAtomicQueueB2,21,i:   6,873,429 msg/sec
+           OptimistAtomicQueueB2,22,s:   5,580,800 msg/sec
+           OptimistAtomicQueueB2,22,i:   7,177,269 msg/sec
+           OptimistAtomicQueueB2,23,s:   5,601,989 msg/sec
+           OptimistAtomicQueueB2,23,i:   7,487,255 msg/sec
+           OptimistAtomicQueueB2,24,s:   5,444,041 msg/sec
+           OptimistAtomicQueueB2,24,i:   7,871,700 msg/sec
+           OptimistAtomicQueueB2,25,s:   5,433,472 msg/sec
+           OptimistAtomicQueueB2,25,i:   8,172,443 msg/sec
+           OptimistAtomicQueueB2,26,s:   5,609,907 msg/sec
+           OptimistAtomicQueueB2,26,i:   8,518,634 msg/sec
+           OptimistAtomicQueueB2,27,s:   5,629,413 msg/sec
+           OptimistAtomicQueueB2,27,i:   8,854,258 msg/sec
+           OptimistAtomicQueueB2,28,s:   6,130,585 msg/sec
+           OptimistAtomicQueueB2,28,i:   9,193,558 msg/sec
+
+---- Running ping-pong benchmarks (lower is better) ----
+     boost::lockfree::spsc_queue: 0.000000321 sec/round-trip
+          boost::lockfree::queue: 0.000000571 sec/round-trip
+                  TicketSpinlock: 0.000000668 sec/round-trip
+   moodycamel::ReaderWriterQueue: 0.000000310 sec/round-trip
+ 
diff --git a/tests/Makefile.generic b/tests/Makefile.generic
index 9143267b..aaad033d 100644
--- a/tests/Makefile.generic
+++ b/tests/Makefile.generic
@@ -23,7 +23,10 @@ BENCH_ROOT?=../..
 
 RUN_TIMEOUT?=28800 # 8 hours.
 TRANSFORM_TIMEOUT?=21600 # 6 hours.
-PROFILE_TIMEOUT?=72000 # 20 hours.
+# PROFILE_TIMEOUT?=36000 # 10 hours.
+PROFILE_TIMEOUT?=7200 # 2 hours.
+PROFILE_TIMEOUT?=86400 # 24 hours.
+# PROFILE_TIMEOUT?=72000 # 20 hours.
 
 REG_NUM_WORKERS?=4
 
@@ -316,7 +319,7 @@ $(CANON).lamp_OG.exe : $(CANON).pgo.bc $(LAMPLIBS)
 #
 
 %.result.slamp.profile: export LINKING_OPTS = $(LINKING_POSTOPTIONS)
-%.result.slamp.profile: %.loopProf.out
+%.result.slamp.profile: $(CANON).bc %.loopProf.out
 	date
 	$(SETUP)
 	$(PROFILESETUP)
@@ -324,7 +327,8 @@ $(CANON).lamp_OG.exe : $(CANON).pgo.bc $(LAMPLIBS)
 	## Need to add a "\" at the end of the next line
 	# DISTANCE_MODULE=1 CONSTANT_VALUE_MODULE=1 CONSTANT_ADDRESS_MODULE=1 LINEAR_VALUE_MODULE=1 LINEAR_ADDRESS_MODULE=1
 	DEFAULT_LDFLAGS="$(DEFAULT_LDFLAGS)" DEFAULT_LIBS="$(DEFAULT_LIBS)" PROFILEARGS="$(ARGS) $(PROFILEARGS)" SETUP="$(SETUP) $(PROFILESETUP)" \
-	regressions-watchdog $(PROFILE_TIMEOUT) slamp.time slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6 2>&1
+	slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6 2>&1
+	# regressions-watchdog $(PROFILE_TIMEOUT) slamp.time slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6 2>&1
 	# LOCALWRITE_THREADS=16 regressions-watchdog $(PROFILE_TIMEOUT) slamp.time slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6 2>&1
 	#NO_DEPENDENCE_MODULE=1 TRACE_MODULE=1 regressions-watchdog $(PROFILE_TIMEOUT) slamp.time slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6-no-module 2>&1
 	#DEFAULT_LDFLAGS="$(DEFAULT_LDFLAGS)" DEFAULT_LIBS="$(DEFAULT_LIBS)" PROFILEARGS="$(ARGS) $(PROFILEARGS)" regressions-watchdog $(PROFILE_TIMEOUT) slamp.time slamp-driver $*.bc $(TARGET_FCN) $(TARGET_LOOP) > rabbit6 2>&1
@@ -342,7 +346,8 @@ $(CANON).lamp_OG.exe : $(CANON).pgo.bc $(LAMPLIBS)
 	$(SETUP)
 	$(PROFILESETUP)
 	rm -f result.specpriv.profile.txt
-	/usr/bin/time --output=$(CANON).specpriv-profile.time -f "%e" ./$< $(PROFILEARGS) >rabbit4 2>&1
+	# /usr/bin/time --output=$(CANON).specpriv-profile.time -f "%e" ./$< $(PROFILEARGS) >rabbit4 2>&1
+	regressions-watchdog $(PROFILE_TIMEOUT) $(CANON).specpriv-profile.time ./$< $(PROFILEARGS) >rabbit4 2>&1
 	@echo -n Waiting for profiler to write result file
 	@for i in `seq 1 1200`; do echo -n .; if [ -r result.specpriv.profile.txt ]; then break; fi; sleep 1; done
 	@echo
@@ -426,7 +431,8 @@ seq.time seq.out: $(PLAIN).o3.exe
 profile-seq.time profile-seq.out: $(PLAIN).o3.exe
 	$(SETUP)
 	$(PROFILESETUP)
-	regressions-watchdog $(RUN_TIMEOUT) profile-seq.time ./$(PLAIN).o3.exe $(PROFILEARGS) > profile-seq.out 2>&1
+	# regressions-watchdog $(RUN_TIMEOUT) profile-seq.time ./$(PLAIN).o3.exe $(PROFILEARGS) > profile-seq.out 2>&1
+	/usr/bin/time -v ./$(PLAIN).o3.exe $(PROFILEARGS) > profile-seq.out 2>&1
 	$(CLEANUP)
 
 reg_seq: $(PLAIN).o3.exe
diff --git a/tests/scripts/convertPromptToSpecPriv.py b/tests/scripts/convertPromptToSpecPriv.py
new file mode 100755
index 00000000..91ef8208
--- /dev/null
+++ b/tests/scripts/convertPromptToSpecPriv.py
@@ -0,0 +1,233 @@
+import os
+import argparse
+
+
+# Parse the rabbit6 file
+def parse_rabbit6(fname):
+    lines = []
+    with open(fname, 'r') as f:
+        lines = f.readlines()
+
+    # Find all "Malloc ID #id : #name" into a dict
+    malloc_id = {}
+    for line in lines:
+        if "Malloc ID" in line:
+            line = line.replace("Malloc ID", "").replace(":", "").strip()
+            mid, name = line.split(" ", 1)
+            name = name.strip()
+            # assert mid is an integer
+            assert mid.isdigit()
+            malloc_id[mid] = name
+
+    # Find all "UO Inst #uoid : #name" into a dict
+    # Or all "UO Arg #uoid : #name" 
+    uo_id = {}
+    for line in lines:
+        if "UO Inst" in line or "UO Arg" in line:
+            line = line.replace("UO Inst", "").replace("UO Arg", "").replace(":", "").strip()
+            print(line)
+            # split by the first space
+            mid, name = line.split(" ", 1)
+            name = name.strip()
+            # assert mid is an integer
+            assert mid.isdigit()
+            uo_id[mid] = name
+
+
+    # Find all "Function ID #fid: #name" into a dict
+    func_id = {}
+    for line in lines:
+        if "Function ID" in line:
+            line = line.replace("Function ID", "").replace(":", "").strip()
+            mid, name = line.split(" ", 1)
+            name = name.strip()
+            # assert mid is an integer
+            assert mid.isdigit()
+            func_id[mid] = name
+
+    # Find all "Loop ID #lid: #name" into a dict
+    loop_id = {}
+    for line in lines:
+        if "Loop ID" in line:
+            line = line.replace("Loop ID", "").replace(":", "").strip()
+            mid, name = line.split(" ", 1)
+            name = name.strip()
+            # assert mid is an integer
+            assert mid.isdigit()
+            loop_id[mid] = name
+
+    return malloc_id, uo_id, func_id, loop_id
+
+def parse_specpriv(fname, id_maps):
+
+    with open(fname, 'r') as f:
+        lines = f.readlines()
+
+    final_lines = []
+
+    # For context, if the first number is 2, it's a loop context, get the name from loop_id map
+    # if the first number is 1, it's a function context, get the name from func_id map
+    # if the first number is 0, it's a Top context, the name is "TOP"
+    def generateContextStr(contexts):
+        # Get context from contexts and parse
+        contexts = contexts.replace("]", "").strip().split(")(")
+
+        context_str = ""
+        # type, id
+        for context in contexts:
+            context = context.replace("(", "").replace(")", "").split(",")
+            ctype, cid = context
+            # assert ctype is an integer
+            assert ctype.isdigit()
+            # assert cid is an integer
+            assert cid.isdigit()
+
+
+            if ctype == "2":
+                # loop context
+                ctype_name = "LOOP"
+                context_name = loop_ids[cid]
+            elif ctype == "1":
+                # function context
+                ctype_name = "FUNCTION"
+                context_name = func_ids[cid]
+            elif ctype == "0":
+                # top context
+                ctype_name = "TOP"
+                context_name = ""
+            else:
+                assert False
+
+            context_str += ctype_name + " " + context_name
+            if ctype != "0":
+                context_str += " WITHIN "
+
+        return context_str
+
+
+    malloc_ids = id_maps['malloc']
+    uo_ids = id_maps['uo']
+    func_ids = id_maps['func']
+    loop_ids = id_maps['loop']
+    loop_context_name = ""
+
+    # Load loop contexts
+    #  LOOP CONTEXTS: 1
+    #  (1,10)(0,0)
+    curLine = 0
+
+    while curLine < len(lines):
+        line = lines[curLine]
+        if "LOOP CONTEXTS" in line:
+            # Get the number of loop contexts
+            num_loop_contexts = int(line.replace("LOOP CONTEXTS: ", "").strip())
+            # assert num_loop_contexts is an integer
+            if num_loop_contexts == 0 or num_loop_contexts > 1:
+                print("ERROR: num_loop_contexts is not 1")
+                exit(1)
+
+            curLine += 1
+            line = lines[curLine]
+            context_str = generateContextStr(line)
+            loop_context_name = context_str
+
+        curLine += 1
+
+
+    # Parse LOCAL OBJECT 279 at context (2,39)(2,35)(2,20)(1,10)(0,0);
+    # Get malloc ID
+    for line in lines:
+        if "LOCAL OBJECT" in line:
+            line = line.replace("LOCAL OBJECT", "").replace("at context", "").replace(";", "").strip()
+            print(line)
+            mid, contexts = line.split(" ", 1)
+
+            # assert oid is an integer
+            assert mid.isdigit()
+
+            # Get the name of the malloc inst
+            malloc_name = malloc_ids[mid]
+            context_str = generateContextStr(contexts)
+
+            final_lines.append("LOCAL OBJECT AU HEAP " +  malloc_name + " FROM CONTEXT { " + context_str + "} IS LOCAL TO CONTEXT { " + loop_context_name + " } COUNT 1")
+
+    # Parse PRED OBJ 282: length of AUs 
+    # AU 24 FROM CONTEXT (1,0)(1,10)(0,0);
+    # The first number is UO ID, the second number is malloc ID
+    curLine = 0
+    while curLine < len(lines):
+        line = lines[curLine]
+        curLine += 1
+        if "PRED OBJ" in line:
+            line = line.replace("PRED OBJ", "").replace("at ", "").replace(":", "").replace(";", "").strip()
+            uoid, contexts, lenAUs = line.split(" ", 2)
+            lenAUs = int(lenAUs)
+
+            context_str = generateContextStr(contexts)
+            uo_name = uo_ids[uoid]
+            uo_str = "PRED OBJ " +  uo_name + " AT CONTEXT { " + context_str + " }  AS PREDICTABLE " + str(lenAUs) + " SAMPLES OVER " + str(lenAUs) + " VALUES { "
+
+            # Parse the AU
+            for i in range(lenAUs):
+                line = lines[curLine]
+                line = line.replace("AU ", "").replace("FROM CONTEXT", "").replace(":", "").replace(";", "").strip()
+
+
+                if "NULL" in line:
+                    # Get the name of the malloc inst
+                    au_str = "( OFFSET 0 BASE AU NULL COUNT 1 )"
+                elif "UNMANAGED" in line:
+                    au_str = "( OFFSET 0 BASE AU HEAP UNMANAGED fopen FROM  CONTEXT { TOP }  COUNT 1 )"
+                else:
+                    malloc_id, contexts = line.split(" ", 1)
+                    assert malloc_id.isdigit()
+
+                    # Get the name of the malloc inst
+                    malloc_name = malloc_ids[malloc_id]
+                    context_str = generateContextStr(contexts)
+                    au_str = "( OFFSET 0 BASE AU HEAP " + malloc_name + " FROM CONTEXT { " + context_str + "} COUNT 1 )"
+
+                uo_str += au_str
+                if i != lenAUs - 1:
+                    uo_str += " , "
+
+                curLine += 1
+
+            uo_str += " }"
+            final_lines.append(uo_str)
+
+    return final_lines
+
+
+# Parse the rabbit6 file and the specpriv-profile.out file
+def parse_args():
+    parser = argparse.ArgumentParser(description='Parse the rabbit6 file and the specpriv-profile.out file')
+    parser.add_argument('-r', '--rabbit6', help='Rabbit6 file', default="rabbit6", type=str)
+    parser.add_argument('-p', '--profile', help='specpriv-profile.out file', default="specpriv-profile.out", type=str)
+    parser.add_argument('-o', '--output', help='Output file', default="specpriv-profile-converted.out", type=str)
+    return parser.parse_args()
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    rabbit6 = args.rabbit6
+    profile = args.profile
+
+    # Parse the rabbit6 file
+    malloc_id, uo_id, func_id, loop_id = parse_rabbit6(rabbit6)
+
+    id_maps = {"malloc": malloc_id, "uo": uo_id, "func": func_id, "loop": loop_id}
+
+    # Parse the specpriv-profile.out file
+    final_lines = parse_specpriv(profile, id_maps)
+    # print all lines to out file
+    with open(args.output, 'w') as f:
+        f.write("BEGIN SPEC PRIV PROFILE\n")
+        f.write("COMPLETE ALLOCATION INFO ;\n")
+
+        for line in final_lines:
+            f.write(line + " ;\n")
+        f.write("END SPEC PRIV PROFILE\n");
+
diff --git a/tests/scripts/cpf-repl b/tests/scripts/cpf-repl
index 4e566397..316c1173 100755
--- a/tests/scripts/cpf-repl
+++ b/tests/scripts/cpf-repl
@@ -39,6 +39,7 @@ LIBS="-load $LIBERTY_LIBS_DIR/libUtil.so
       -load $LIBERTY_LIBS_DIR/libOrchestration.so
       -load $LIBERTY_LIBS_DIR/libSpeculation.so
       -load $LIBERTY_LIBS_DIR/libCodeGen.so
+      -load $NOELLE_LIBS_DIR/Repl.so
       -load $LIBERTY_LIBS_DIR/libRepl.so"
 
 AA=`aa`
@@ -46,7 +47,7 @@ AA=`aa`
 EXTRA="-basicaa -globals-aa -cfl-steens-aa -tbaa -scev-aa -cfl-anders-aa -objc-arc-aa -scoped-noalias -veto -nander"
 
 OPTS="$LPROF $SLPROF $AA $EXTRA $SPPROF
-  -opt-repl $DBG"
+  -cpf-repl $DBG"
 
 OUT="-disable-output"
 CMD="noelle-load $LIBS $OPTS $1 $OUT ${@:2}"
diff --git a/tests/scripts/slamp-driver b/tests/scripts/slamp-driver
index 3ddb8fc8..241c64ee 100755
--- a/tests/scripts/slamp-driver
+++ b/tests/scripts/slamp-driver
@@ -22,7 +22,7 @@ function drive {
      -load $LIBERTY_LIBS_DIR/libStrategy.so
      -load $SCAF_LIBS_DIR/libLoopProf.so
      -load $SCAF_LIBS_DIR/libLAMPLoad.so
-     -load $SCAF_LIBS_DIR/libPointsToProfiler.so
+     -load $LIBERTY_LIBS_DIR/libPointsToProfiler.so
      -load $NOELLE_LIBS_DIR/AllocAA.so
      -load $NOELLE_LIBS_DIR/TalkDown.so 
      -load $NOELLE_LIBS_DIR/CallGraph.so 
@@ -45,7 +45,9 @@ function drive {
      -load $LIBERTY_LIBS_DIR/libSLAMP.so
      -basic-loop-aa -scev-loop-aa -auto-restrict-aa -intrinsic-aa -global-malloc-aa -pure-fun-aa -semi-local-fun-aa -phi-maze-aa -no-capture-global-aa -no-capture-src-aa -type-aa -no-escape-fields-aa -acyclic-aa -disjoint-fields-aa -field-malloc-aa -loop-variant-allocation-aa -std-in-out-err-aa -array-of-structures-aa -kill-flow-aa -callsite-depth-combinator-aa -unique-access-paths-aa $EXTRA -llvm-aa-results  -pdgbuilder "
 
-  local SLAMP_HOOKS="$LIBERTY_LIBS_DIR/libslamp_hooks.a"
+  # local SLAMP_HOOKS="$LIBERTY_LIBS_DIR/libslamp_hooks_stats.a"
+  local SLAMP_HOOKS="/u/NAS_SCRATCH/ziyangx/cpf-workspace-9-master/build/cpf-build-release/lib/SLAMP/SLAMPcustom/libslamp_hooks_custom.a"
+  # local SLAMP_HOOKS="/u/NAS_SCRATCH/ziyangx/cpf-workspace-9-master/build/cpf-build-release/lib/SLAMP/SLAMPsmtxq/libslamp_hooks_smtx.a"
   local SLAMP_OUTFILE="$2-$3.result.slamp.profile"
 
  local OPTS="-slamp-insts -slamp-target-fn=$2 -slamp-target-loop=$3 $EXTRA_FLAGS -slamp-outfile=$SLAMP_OUTFILE"
@@ -76,7 +78,8 @@ function drive {
   # local CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -o $EXE -g $DEFAULT_LDFLAGS -lunwind $DEFAULT_LIBS -ldl -lutil" 
   #local CMD3="g++ -Og $PRELINK_OBJ $SLAMP_HOOKS -o $EXE -g $DEFAULT_LDFLAGS -lunwind $DEFAULT_LIBS -ldl -lutil" 
 
-  RAW_CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil" 
+  # RAW_CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil" 
+  RAW_CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil -lpthread -lrt " 
   if [[ x$LTO != x ]]; then
       RAW_CMD3+=" -flto"
   fi
@@ -93,7 +96,7 @@ function drive {
           echo -e "#include <stdio.h>\nconst char LOCALWRITE_MODULE=0;const size_t LOCALWRITE_MASK=0; const size_t LOCALWRITE_PATTERN=0;" | clang -x c -c -o constants.o -
       fi
       # CMD3="clang++ -flto -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS constants.o -o $EXE -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil"
-      CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -o $EXE -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil"
+      CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -o $EXE -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil  -lpthread -lrt"
       #CMD3="clang++ -no-pie  -O2 $PRELINK_OBJ $SLAMP_HOOKS -mllvm -inline-threshold=5000 -o $EXE -g $LINKING_OPTS -lunwind $DEFAULT_LIBS -ldl -lutil"
   fi
 
@@ -128,11 +131,44 @@ function drive {
   echo -e "${red}    --- Run Simulator...${nc}"
   echo $CMD4
   #time $CMD4 > /dev/null 2>&1
-  eval time $CMD4
-  if [[ $? -ne 0 ]]; then
-    echo -e "${red}    --- SIMULATION FAILED${nc}"
-    rm -f result.slamp.profile
-    exit 1
+
+  # CMD4="taskset --cpu-list 7-8 $CMD4"
+
+  rm -f /dev/shm/MySharedMemory2 /dev/shm/MySharedMemory
+
+  # create a random number between 0 and 999
+  slamp_queue_id=$(($RANDOM%1000))
+
+  # check if /dev/shm/slamp_queue_$id exists and if so, create a new random number
+  while [ -e /dev/shm/slamp_queue_$slamp_queue_id ]; do
+      slamp_queue_id=$(($RANDOM%1000))
+  done
+
+
+  # # taskset --cpu-list 0-6,9-55 /u/NAS_SCRATCH/ziyangx/cpf-workspace-9-master/cpf/liberty/lib/SLAMP/SLAMPcustom/consumer/build/consumer &
+  # /u/NAS_SCRATCH/ziyangx/cpf-workspace-9-master/cpf/liberty/lib/SLAMP/SLAMPsmtxq/consumer/build/consumer &
+  SLAMP_QUEUE_ID=$slamp_queue_id /usr/bin/time -v /u/NAS_SCRATCH/ziyangx/cpf-workspace-9-master/cpf/liberty/lib/SLAMP/SLAMPcustom/consumer/build/consumer &
+  CONSUME_PID=$!
+  RUN_TIMEOUT=7200 # 2 hours
+  echo "timeout $RUN_TIMEOUT SLAMP_QUEUE_ID=$slamp_queue_id $CMD4"
+  SLAMP_QUEUE_ID=$slamp_queue_id eval /usr/bin/time -v regressions-watchdog $RUN_TIMEOUT slamp-custom.time $CMD4
+  # eval regressions-watchdog $RUN_TIMEOUT slamp-smtx.time $CMD4
+  # if command fail
+  if [ $? -ne 0 ]; then
+      # print in red
+      kill -9 $CONSUME_PID
+      echo -e "${red}    --- SIMULATION FAILED${nc}"
+      echo "Timed out or other problems"
+      rm -f result.slamp.profile
+      rm -f /dev/shm/slamp_queue_$slamp_queue_id
+      exit 1
+  else
+      # sleep for 20 seconds
+      sleep 10
+      # sleep 0
+      cat deplog*.txt >> result.slamp.profile
+      rm -f deplog*.txt
+      rm -f /dev/shm/slamp_queue_$slamp_queue_id
   fi
 
   if [[ x$LOCALWRITE_THREADS != x ]]; then
@@ -192,8 +228,8 @@ while IFS=$'\n' read -r line_data; do
 done < __targets.txt
 
 let i=0
-# while (( i < 2 )); do
-while (( ${#lines[@]} > i )); do
+while (( i < 2 )); do
+# while (( ${#lines[@]} > i )); do
   IFS=' ' read -a array <<< ${lines[i++]}
   if [ ${array[0]} == "-" ]; then
     drive $1 ${array[1]} ${array[3]}
diff --git a/tests/slamp-test/specpriv_counter1/src/Makefile b/tests/slamp-test/specpriv_counter1/src/Makefile
new file mode 100644
index 00000000..2b0747f7
--- /dev/null
+++ b/tests/slamp-test/specpriv_counter1/src/Makefile
@@ -0,0 +1,5 @@
+PROFILESETUP=
+PROFILEARGS=10000 100 20
+
+#NOINLINE=1
+include ../../../Makefile.generic
diff --git a/tests/slamp-test/specpriv_counter1/src/test.c b/tests/slamp-test/specpriv_counter1/src/test.c
new file mode 100644
index 00000000..77d70a47
--- /dev/null
+++ b/tests/slamp-test/specpriv_counter1/src/test.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define N 1000000
+int main() {
+  // have a loop that malloc in one iteration and free in the next
+  int *p;
+  for (int i = 0; i < N; i++) {
+    if (i == 0) {
+      p = (int *) malloc(sizeof(int));
+      *p = 0;
+    }
+    else if (i == N - 1) {
+      free(p);
+    } else {
+      *p = *p + 1;
+    }
+  }
+
+}