.vscode/settings.json

@@ -0,0 +1,63 @@
+{
+    "C_Cpp.default.configurationProvider": "go2sh.cmake-integration",
+    "files.associations": {
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "chrono": "cpp",
+        "condition_variable": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp"
+    }
+}

CMakeLists.txt

@@ -3,28 +3,12 @@ project(another_studproject)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS "-O3 -flto=thin -march=native")
-
-# Process Abseil's CMake build system
-add_subdirectory(./src/includes/3thparty/abseil-cpp
-                ./src/includes/3thparty/tsl
-                )
-
-
-add_executable(studproject 
+add_executable(another_studproject 
                 ./src/includes/generator.h
                 ./src/generator.cpp
                 ./src/includes/tests.h
                 ./src/includes/aggregate_tests.h
-                ./src/includes/3thparty/emilib/loguru.cpp
-                ./src/main.cpp
-)
+                main.cpp
                 
-target_link_libraries(studproject 
-                        absl::hash 
-                        absl::node_hash_map 
-                        absl::flat_hash_map 
-                        pthread 
-                        dl
-                        stdc++fs
-)
 
+)

README.md

@@ -1,27 +0,0 @@
-
-# Instructions
-after the project is cloned, run `git submodule update --init --recursive` to pull submodules. 
-This is stuff like abseil and other maps are git submodules that don't get downloaded automatically. 
-
-To build, just run
-`mkdir build`  
-`cd build`  
-`cmake .. -G "<Build System>"` and then whatever command the build system uses.
-For example, with unix maketools:
-
-`cmake -G "Unix makefiles"`
-`make`
-
-But if you still got the same config as the one we all used for parkmanne, you should have vscode + cmaketools plugin. In which case, just press build. 
-
-
-## Dependencies
-Install boost. (https://www.boost.org/) should just be `pacman -S mingw-w64-x86_64-boost` in the msys2 shell. If you still have the same install as the parkmanne project, you already have this installed.
-If you don't for some reason, see command above. If you don't have the same setup anymore, ask me. Stefan, it is `apt install libboost-all-dev` on ubuntu if i remember correctly. `pacman -S boost-libs` on manjaro.  
-We need it for `boost::unordered`, and i have no easy way to include it in the project.
- 
-Also, this is only tested on linux. It *should* work on windows. I remember it working on windows, but I recently did a fresh install on windows after getting an SSD and I'm having trouble configuring clang to work for projects I was able to compile in the past.
-Assume it doesnt and compile on linux. 
-
-Also, make sure your compiler supports C++17. That should be the latest versions all major compilers (clang 5+, gcc 7+, msvc 19.14+ (Visual studio 2017+))
-We're at VS2019, clang 10 and gcc 9 now, so this shouldn't be an issue if you still got the parkmanne setup.

clang-format

@@ -1,62 +0,0 @@
----
-BasedOnStyle: WebKit
-AccessModifierOffset: '0'
-AlignAfterOpenBracket: Align
-AlignConsecutiveMacros: 'true'
-AlignConsecutiveAssignments: 'true'
-AlignEscapedNewlines: Left
-AlignTrailingComments: 'true'
-AllowAllArgumentsOnNextLine: 'true'
-AllowAllConstructorInitializersOnNextLine: 'true'
-AllowAllParametersOfDeclarationOnNextLine: 'true'
-AllowShortBlocksOnASingleLine: 'true'
-AllowShortCaseLabelsOnASingleLine: 'true'
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: Never
-AlwaysBreakTemplateDeclarations: 'Yes'
-BinPackArguments: 'false'
-BinPackParameters: 'false'
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Stroustrup
-BreakBeforeTernaryOperators: 'false'
-BreakConstructorInitializers: AfterColon
-BreakInheritanceList: AfterColon
-BreakStringLiterals: 'true'
-ColumnLimit: '100'
-CompactNamespaces: 'true'
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-ConstructorInitializerIndentWidth: '4'
-ContinuationIndentWidth: '4'
-Cpp11BracedListStyle: 'true'
-DerivePointerAlignment: 'false'
-DisableFormat: 'false'
-FixNamespaceComments: 'true'
-IncludeBlocks: Merge
-IndentCaseLabels: 'true'
-IndentWidth: '4'
-IndentWrappedFunctionNames: 'false'
-KeepEmptyLinesAtTheStartOfBlocks: 'true'
-Language: Cpp
-NamespaceIndentation: None
-PointerAlignment: Left
-ReflowComments: 'true'
-SortIncludes: 'true'
-SortUsingDeclarations: 'true'
-SpaceAfterCStyleCast: 'true'
-SpaceAfterLogicalNot: 'false'
-SpaceAfterTemplateKeyword: 'false'
-SpaceBeforeAssignmentOperators: 'true'
-SpaceBeforeCpp11BracedList: 'true'
-SpaceBeforeCtorInitializerColon: 'false'
-SpaceBeforeInheritanceColon: 'false'
-SpaceBeforeParens: ControlStatements
-SpaceBeforeRangeBasedForLoopColon: 'true'
-SpacesInAngles: 'false'
-SpacesInCStyleCastParentheses: 'false'
-SpacesInContainerLiterals: 'false'
-SpacesInParentheses: 'false'
-SpacesInSquareBrackets: 'false'
-Standard: Cpp11
-UseTab: ForContinuationAndIndentation
-
-...

cmake-build-debug/CMakeFiles/3.15.5/CMakeCCompiler.cmake

@@ -0,0 +1,76 @@
+set(CMAKE_C_COMPILER "/usr/bin/clang")
+set(CMAKE_C_COMPILER_ARG1 "")
+set(CMAKE_C_COMPILER_ID "Clang")
+set(CMAKE_C_COMPILER_VERSION "9.0.0")
+set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_C_COMPILER_WRAPPER "")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11")
+set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert")
+set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
+set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros")
+set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
+
+set(CMAKE_C_PLATFORM_ID "Linux")
+set(CMAKE_C_SIMULATE_ID "")
+set(CMAKE_C_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_C_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_C_COMPILER_AR "/usr/bin/llvm-ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_C_COMPILER_RANLIB "/usr/bin/llvm-ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCC )
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "8")
+set(CMAKE_C_COMPILER_ABI "ELF")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/usr/local/include;/usr/lib/clang/9.0.0/include;/usr/include")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib64/gcc/x86_64-pc-linux-gnu/9.2.0;/usr/lib64;/lib64;/usr/lib;/lib")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

cmake-build-debug/CMakeFiles/3.15.5/CMakeCXXCompiler.cmake

@@ -0,0 +1,79 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "Clang")
+set(CMAKE_CXX_COMPILER_VERSION "9.0.0")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
+set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
+set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
+set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
+set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
+set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/llvm-ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/llvm-ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCXX )
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;mm;CPP)
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
+
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "")
+endif()
+
+set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/9.2.0;/usr/include/c++/9.2.0/x86_64-pc-linux-gnu;/usr/include/c++/9.2.0/backward;/usr/local/include;/usr/lib/clang/9.0.0/include;/usr/include")
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib64/gcc/x86_64-pc-linux-gnu/9.2.0;/usr/lib64;/lib64;/usr/lib;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

cmake-build-debug/CMakeFiles/3.15.5/CMakeSystem.cmake

@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-5.3.12-1-MANJARO")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "5.3.12-1-MANJARO")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-5.3.12-1-MANJARO")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "5.3.12-1-MANJARO")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)

cmake-build-debug/CMakeFiles/3.15.5/CompilerIdC/CMakeCCompilerId.c

@@ -0,0 +1,665 @@
+#ifdef __cplusplus
+# error "A C++ compiler has been selected for C."
+#endif
+
+#if defined(__18CXX)
+# define ID_VOID_MAIN
+#endif
+#if defined(__CLASSIC_C__)
+/* cv-qualifiers did not exist in K&R C */
+# define const
+# define volatile
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_C)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_C >= 0x5100
+   /* __SUNPRO_C = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# endif
+
+#elif defined(__HP_cc)
+# define COMPILER_ID "HP"
+  /* __HP_cc = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_cc     % 100)
+
+#elif defined(__DECC)
+# define COMPILER_ID "Compaq"
+  /* __DECC_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECC_VER         % 10000)
+
+#elif defined(__IBMC__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__TINYC__)
+# define COMPILER_ID "TinyCC"
+
+#elif defined(__BCC__)
+# define COMPILER_ID "Bruce"
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__)
+# define COMPILER_ID "GNU"
+# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
+# define COMPILER_ID "SDCC"
+# if defined(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
+#  define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
+# else
+  /* SDCC = VRP */
+#  define COMPILER_VERSION_MAJOR DEC(SDCC/100)
+#  define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(SDCC    % 10)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if !defined(__STDC__)
+# if (defined(_MSC_VER) && !defined(__clang__)) \
+  || (defined(__ibmxl__) || defined(__IBMC__))
+#  define C_DIALECT "90"
+# else
+#  define C_DIALECT
+# endif
+#elif __STDC_VERSION__ >= 201000L
+# define C_DIALECT "11"
+#elif __STDC_VERSION__ >= 199901L
+# define C_DIALECT "99"
+#else
+# define C_DIALECT "90"
+#endif
+const char* info_language_dialect_default =
+  "INFO" ":" "dialect_default[" C_DIALECT "]";
+
+/*--------------------------------------------------------------------------*/
+
+#ifdef ID_VOID_MAIN
+void main() {}
+#else
+# if defined(__CLASSIC_C__)
+int main(argc, argv) int argc; char *argv[];
+# else
+int main(int argc, char* argv[])
+# endif
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+  require += info_arch[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}
+#endif

cmake-build-debug/CMakeFiles/3.15.5/CompilerIdCXX/CMakeCXXCompilerId.cpp

@@ -0,0 +1,644 @@
+/* This source file must have a .cpp extension so that all C++ compilers
+   recognize the extension without flags.  Borland does not know .cxx for
+   example.  */
+#ifndef __cplusplus
+# error "A C compiler has been selected for C++."
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__COMO__)
+# define COMPILER_ID "Comeau"
+  /* __COMO_VERSION__ = VRR */
+# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
+
+#elif defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_CC)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_CC >= 0x5100
+   /* __SUNPRO_CC = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# endif
+
+#elif defined(__HP_aCC)
+# define COMPILER_ID "HP"
+  /* __HP_aCC = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_aCC     % 100)
+
+#elif defined(__DECCXX)
+# define COMPILER_ID "Compaq"
+  /* __DECCXX_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER         % 10000)
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__) || defined(__GNUG__)
+# define COMPILER_ID "GNU"
+# if defined(__GNUC__)
+#  define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if defined(_MSC_VER) && defined(_MSVC_LANG)
+#define CXX_STD _MSVC_LANG
+#else
+#define CXX_STD __cplusplus
+#endif
+
+const char* info_language_dialect_default = "INFO" ":" "dialect_default["
+#if CXX_STD > 201703L
+  "20"
+#elif CXX_STD >= 201703L
+  "17"
+#elif CXX_STD >= 201402L
+  "14"
+#elif CXX_STD >= 201103L
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}

cmake-build-debug/CMakeFiles/CMakeDirectoryInformation.cmake

@@ -1,9 +1,9 @@
 # CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
 
 # Relative path conversion top directories.
-set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/hello_user/hashmap-bench")
-set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/hello_user/hashmap-bench")
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/massiveatoms/Desktop/studieproject/homebrew")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug")
 
 # Force unix paths in dependencies.
 set(CMAKE_FORCE_UNIX_PATHS 1)

cmake-build-debug/CMakeFiles/Makefile.cmake

@@ -0,0 +1,126 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "../CMakeLists.txt"
+  "CMakeFiles/3.15.5/CMakeCCompiler.cmake"
+  "CMakeFiles/3.15.5/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.15.5/CMakeSystem.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeCCompiler.cmake.in"
+  "/usr/share/cmake-3.15/Modules/CMakeCCompilerABI.c"
+  "/usr/share/cmake-3.15/Modules/CMakeCInformation.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeCXXCompiler.cmake.in"
+  "/usr/share/cmake-3.15/Modules/CMakeCXXCompilerABI.cpp"
+  "/usr/share/cmake-3.15/Modules/CMakeCXXInformation.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeCommonLanguageInclude.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeCompilerIdDetection.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCXXCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCompileFeatures.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCompilerABI.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineCompilerId.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeDetermineSystem.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeFindBinUtils.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeFindCodeBlocks.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeGenericSystem.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeInitializeConfigs.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeLanguageInformation.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeParseImplicitIncludeInfo.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeParseImplicitLinkInfo.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeSystem.cmake.in"
+  "/usr/share/cmake-3.15/Modules/CMakeSystemSpecificInformation.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeTestCCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeTestCXXCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeTestCompilerCommon.cmake"
+  "/usr/share/cmake-3.15/Modules/CMakeUnixFindMake.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/ADSP-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Borland-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang-C.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang-CXX.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang-FindBinUtils.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Clang.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Cray-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/GHS-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/GNU.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/HP-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/IAR-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Intel-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/MSVC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/PGI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/PathScale-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/SCO-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/TI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/Watcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/XL-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.15/Modules/Internal/CMakeCheckCompilerFlag.cmake"
+  "/usr/share/cmake-3.15/Modules/Internal/FeatureTesting.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-Clang-C.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-Clang-CXX.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-Determine-CXX.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-GNU-C.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-GNU-CXX.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux-GNU.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/Linux.cmake"
+  "/usr/share/cmake-3.15/Modules/Platform/UnixPaths.cmake"
+  "/usr/share/cmake-3.15/Modules/ProcessorCount.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "CMakeFiles/3.15.5/CMakeSystem.cmake"
+  "CMakeFiles/3.15.5/CMakeCCompiler.cmake"
+  "CMakeFiles/3.15.5/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.15.5/CMakeCCompiler.cmake"
+  "CMakeFiles/3.15.5/CMakeCXXCompiler.cmake"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/another_studproject.dir/DependInfo.cmake"
+  )

cmake-build-debug/CMakeFiles/Makefile2

@@ -0,0 +1,111 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+# The main recursive all target
+all:
+
+.PHONY : all
+
+# The main recursive preinstall target
+preinstall:
+
+.PHONY : preinstall
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/massiveatoms/Desktop/studieproject/homebrew
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "clean" target.
+clean: CMakeFiles/another_studproject.dir/clean
+
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/another_studproject.dir
+
+# All Build rule for target.
+CMakeFiles/another_studproject.dir/all:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/depend
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles --progress-num=1,2 "Built target another_studproject"
+.PHONY : CMakeFiles/another_studproject.dir/all
+
+# Include target in all.
+all: CMakeFiles/another_studproject.dir/all
+
+.PHONY : all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/another_studproject.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles 2
+	$(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/another_studproject.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles 0
+.PHONY : CMakeFiles/another_studproject.dir/rule
+
+# Convenience name for target.
+another_studproject: CMakeFiles/another_studproject.dir/rule
+
+.PHONY : another_studproject
+
+# clean rule for target.
+CMakeFiles/another_studproject.dir/clean:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/clean
+.PHONY : CMakeFiles/another_studproject.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+

cmake-build-debug/CMakeFiles/TargetDirectories.txt

@@ -0,0 +1,3 @@
+/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/rebuild_cache.dir
+/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/another_studproject.dir
+/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/edit_cache.dir

cmake-build-debug/CMakeFiles/another_studproject.dir/CXX.includecache

@@ -6,5 +6,23 @@
 
 #IncludeRegexTransform: 
 
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/debugging/leak_check_disable.cc
+/home/massiveatoms/Desktop/studieproject/homebrew/main.cpp
+iostream
+-
+vector
+-
+unordered_map
+-
+algorithm
+-
+random
+-
+iterator
+-
+chrono
+-
+string
+-
+math.h
+-
 

cmake-build-debug/CMakeFiles/another_studproject.dir/DependInfo.cmake

@@ -4,13 +4,12 @@ set(CMAKE_DEPENDS_LANGUAGES
   )
 # The set of files for implicit dependencies of each language:
 set(CMAKE_DEPENDS_CHECK_CXX
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/numeric/int128.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/numeric/CMakeFiles/absl_int128.dir/int128.cc.o"
+  "/home/massiveatoms/Desktop/studieproject/homebrew/main.cpp" "/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/another_studproject.dir/main.cpp.o"
   )
-set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_ID "Clang")
 
 # The include file search paths:
 set(CMAKE_CXX_TARGET_INCLUDE_PATH
-  "src/includes/3thparty/abseil-cpp"
   )
 
 # Targets to which this target links.

cmake-build-debug/CMakeFiles/another_studproject.dir/build.make

@@ -0,0 +1,98 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/massiveatoms/Desktop/studieproject/homebrew
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug
+
+# Include any dependencies generated for this target.
+include CMakeFiles/another_studproject.dir/depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/another_studproject.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include CMakeFiles/another_studproject.dir/flags.make
+
+CMakeFiles/another_studproject.dir/main.cpp.o: CMakeFiles/another_studproject.dir/flags.make
+CMakeFiles/another_studproject.dir/main.cpp.o: ../main.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/another_studproject.dir/main.cpp.o"
+	/usr/bin/clang++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/another_studproject.dir/main.cpp.o -c /home/massiveatoms/Desktop/studieproject/homebrew/main.cpp
+
+CMakeFiles/another_studproject.dir/main.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/another_studproject.dir/main.cpp.i"
+	/usr/bin/clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/massiveatoms/Desktop/studieproject/homebrew/main.cpp > CMakeFiles/another_studproject.dir/main.cpp.i
+
+CMakeFiles/another_studproject.dir/main.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/another_studproject.dir/main.cpp.s"
+	/usr/bin/clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/massiveatoms/Desktop/studieproject/homebrew/main.cpp -o CMakeFiles/another_studproject.dir/main.cpp.s
+
+# Object files for target another_studproject
+another_studproject_OBJECTS = \
+"CMakeFiles/another_studproject.dir/main.cpp.o"
+
+# External object files for target another_studproject
+another_studproject_EXTERNAL_OBJECTS =
+
+another_studproject: CMakeFiles/another_studproject.dir/main.cpp.o
+another_studproject: CMakeFiles/another_studproject.dir/build.make
+another_studproject: CMakeFiles/another_studproject.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable another_studproject"
+	$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/another_studproject.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+CMakeFiles/another_studproject.dir/build: another_studproject
+
+.PHONY : CMakeFiles/another_studproject.dir/build
+
+CMakeFiles/another_studproject.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/another_studproject.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/another_studproject.dir/clean
+
+CMakeFiles/another_studproject.dir/depend:
+	cd /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/massiveatoms/Desktop/studieproject/homebrew /home/massiveatoms/Desktop/studieproject/homebrew /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/another_studproject.dir/DependInfo.cmake --color=$(COLOR)
+.PHONY : CMakeFiles/another_studproject.dir/depend
+

cmake-build-debug/CMakeFiles/another_studproject.dir/cmake_clean.cmake

@@ -0,0 +1,10 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/another_studproject.dir/main.cpp.o"
+  "another_studproject"
+  "another_studproject.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/another_studproject.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()

cmake-build-debug/CMakeFiles/another_studproject.dir/depend.internal

@@ -0,0 +1,5 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+CMakeFiles/another_studproject.dir/main.cpp.o
+ /home/massiveatoms/Desktop/studieproject/homebrew/main.cpp

cmake-build-debug/CMakeFiles/another_studproject.dir/depend.make

@@ -0,0 +1,5 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+CMakeFiles/another_studproject.dir/main.cpp.o: ../main.cpp
+

cmake-build-debug/CMakeFiles/another_studproject.dir/flags.make

@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
+
+# compile CXX with /usr/bin/clang++
+CXX_FLAGS = -g   -std=gnu++17
+
+CXX_DEFINES = 
+
+CXX_INCLUDES = 
+

cmake-build-debug/CMakeFiles/another_studproject.dir/link.txt

@@ -0,0 +1 @@
+/usr/bin/clang++  -g   CMakeFiles/another_studproject.dir/main.cpp.o  -o another_studproject 

cmake-build-debug/CMakeFiles/another_studproject.dir/progress.make

@@ -1,3 +1,3 @@
-CMAKE_PROGRESS_1 = 
+CMAKE_PROGRESS_1 = 1
 CMAKE_PROGRESS_2 = 2
 

cmake-build-debug/CMakeFiles/clion-log.txt

@@ -0,0 +1,18 @@
+/usr/bin/cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G "CodeBlocks - Unix Makefiles" /home/massiveatoms/Desktop/studieproject/homebrew
+-- The C compiler identification is Clang 9.0.0
+-- The CXX compiler identification is Clang 9.0.0
+-- Check for working C compiler: /usr/bin/clang
+-- Check for working C compiler: /usr/bin/clang -- works
+-- Detecting C compiler ABI info
+-- Detecting C compiler ABI info - done
+-- Detecting C compile features
+-- Detecting C compile features - done
+-- Check for working CXX compiler: /usr/bin/clang++
+-- Check for working CXX compiler: /usr/bin/clang++ -- works
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Detecting CXX compile features
+-- Detecting CXX compile features - done
+-- Configuring done
+-- Generating done
+-- Build files have been written to: /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug

cmake-build-debug/CMakeFiles/cmake.check_cache

@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file

cmake-build-debug/CMakeFiles/progress.marks

@@ -0,0 +1 @@
+2

cmake-build-debug/Makefile

@@ -1,5 +1,5 @@
 # CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
+# Generated by "Unix Makefiles" Generator, CMake Version 3.15
 
 # Default target executed when no arguments are given to make.
 default_target: all
@@ -17,25 +17,8 @@ default_target: all
 .SUFFIXES:
 
 
-# Disable VCS-based implicit rules.
-% : %,v
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-
-# Disable VCS-based implicit rules.
-% : s.%
-
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
 
 .SUFFIXES: .hpux_make_needs_suffix_list
 
@@ -59,16 +42,16 @@ SHELL = /bin/sh
 CMAKE_COMMAND = /usr/bin/cmake
 
 # The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
+RM = /usr/bin/cmake -E remove -f
 
 # Escaping for special characters.
 EQUALS = =
 
 # The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/hello_user/hashmap-bench
+CMAKE_SOURCE_DIR = /home/massiveatoms/Desktop/studieproject/homebrew
 
 # The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
+CMAKE_BINARY_DIR = /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug
 
 #=============================================================================
 # Targets provided globally by CMake.
@@ -76,7 +59,7 @@ CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
 # Special rule for the target rebuild_cache
 rebuild_cache:
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
-	/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+	/usr/bin/cmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
 .PHONY : rebuild_cache
 
 # Special rule for the target rebuild_cache
@@ -87,7 +70,7 @@ rebuild_cache/fast: rebuild_cache
 # Special rule for the target edit_cache
 edit_cache:
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
-	/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+	/usr/bin/cmake-gui -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
 .PHONY : edit_cache
 
 # Special rule for the target edit_cache
@@ -97,14 +80,14 @@ edit_cache/fast: edit_cache
 
 # The main all target
 all: cmake_check_build_system
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/algorithm/CMakeFiles/progress.marks
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/algorithm/all
-	$(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles 0
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles/progress.marks
+	$(MAKE) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/CMakeFiles 0
 .PHONY : all
 
 # The main clean target
 clean:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/algorithm/clean
+	$(MAKE) -f CMakeFiles/Makefile2 clean
 .PHONY : clean
 
 # The main clean target
@@ -114,27 +97,71 @@ clean/fast: clean
 
 # Prepare targets for installation.
 preinstall: all
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/algorithm/preinstall
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
 .PHONY : preinstall
 
 # Prepare targets for installation.
 preinstall/fast:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/algorithm/preinstall
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
 .PHONY : preinstall/fast
 
 # clear depends
 depend:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
 .PHONY : depend
 
+#=============================================================================
+# Target rules for targets named another_studproject
+
+# Build rule for target.
+another_studproject: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 another_studproject
+.PHONY : another_studproject
+
+# fast build rule for target.
+another_studproject/fast:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/build
+.PHONY : another_studproject/fast
+
+main.o: main.cpp.o
+
+.PHONY : main.o
+
+# target to build an object file
+main.cpp.o:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/main.cpp.o
+.PHONY : main.cpp.o
+
+main.i: main.cpp.i
+
+.PHONY : main.i
+
+# target to preprocess a source file
+main.cpp.i:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/main.cpp.i
+.PHONY : main.cpp.i
+
+main.s: main.cpp.s
+
+.PHONY : main.s
+
+# target to generate assembly for a file
+main.cpp.s:
+	$(MAKE) -f CMakeFiles/another_studproject.dir/build.make CMakeFiles/another_studproject.dir/main.cpp.s
+.PHONY : main.cpp.s
+
 # Help Target
 help:
 	@echo "The following are some of the valid targets for this Makefile:"
 	@echo "... all (the default if no target is provided)"
 	@echo "... clean"
 	@echo "... depend"
-	@echo "... edit_cache"
 	@echo "... rebuild_cache"
+	@echo "... another_studproject"
+	@echo "... edit_cache"
+	@echo "... main.o"
+	@echo "... main.i"
+	@echo "... main.s"
 .PHONY : help
 
 
@@ -146,6 +173,6 @@ help:
 # No rule that depends on this can have commands that come from listfiles
 # because they might be regenerated.
 cmake_check_build_system:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
 .PHONY : cmake_check_build_system
 

cmake-build-debug/another_studproject.cbp

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6"/>
+	<Project>
+		<Option title="another_studproject"/>
+		<Option makefile_is_custom="1"/>
+		<Option compiler="clang"/>
+		<Option virtualFolders="CMake Files\;"/>
+		<Build>
+			<Target title="all">
+				<Option working_dir="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug"/>
+				<Option type="4"/>
+				<MakeCommands>
+					<Build command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 all"/>
+					<CompileFile command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 &quot;$file&quot;"/>
+					<Clean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+					<DistClean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+				</MakeCommands>
+			</Target>
+			<Target title="rebuild_cache">
+				<Option working_dir="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug"/>
+				<Option type="4"/>
+				<MakeCommands>
+					<Build command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 rebuild_cache"/>
+					<CompileFile command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 &quot;$file&quot;"/>
+					<Clean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+					<DistClean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+				</MakeCommands>
+			</Target>
+			<Target title="another_studproject">
+				<Option output="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/another_studproject" prefix_auto="0" extension_auto="0"/>
+				<Option working_dir="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug"/>
+				<Option object_output="./"/>
+				<Option type="1"/>
+				<Option compiler="clang"/>
+				<Compiler>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0"/>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0/x86_64-pc-linux-gnu"/>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0/backward"/>
+					<Add directory="/usr/local/include"/>
+					<Add directory="/usr/lib/clang/9.0.0/include"/>
+					<Add directory="/usr/include"/>
+				</Compiler>
+				<MakeCommands>
+					<Build command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 another_studproject"/>
+					<CompileFile command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 &quot;$file&quot;"/>
+					<Clean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+					<DistClean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+				</MakeCommands>
+			</Target>
+			<Target title="another_studproject/fast">
+				<Option output="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/another_studproject" prefix_auto="0" extension_auto="0"/>
+				<Option working_dir="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug"/>
+				<Option object_output="./"/>
+				<Option type="1"/>
+				<Option compiler="clang"/>
+				<Compiler>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0"/>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0/x86_64-pc-linux-gnu"/>
+					<Add directory="/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/9.2.0/../../../../include/c++/9.2.0/backward"/>
+					<Add directory="/usr/local/include"/>
+					<Add directory="/usr/lib/clang/9.0.0/include"/>
+					<Add directory="/usr/include"/>
+				</Compiler>
+				<MakeCommands>
+					<Build command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 another_studproject/fast"/>
+					<CompileFile command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 &quot;$file&quot;"/>
+					<Clean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+					<DistClean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+				</MakeCommands>
+			</Target>
+			<Target title="edit_cache">
+				<Option working_dir="/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug"/>
+				<Option type="4"/>
+				<MakeCommands>
+					<Build command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 edit_cache"/>
+					<CompileFile command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 &quot;$file&quot;"/>
+					<Clean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+					<DistClean command="/usr/bin/make -j4 -f &quot;/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/Makefile&quot;  VERBOSE=1 clean"/>
+				</MakeCommands>
+			</Target>
+		</Build>
+		<Unit filename="/home/massiveatoms/Desktop/studieproject/homebrew/main.cpp">
+			<Option target="another_studproject"/>
+		</Unit>
+		<Unit filename="/home/massiveatoms/Desktop/studieproject/homebrew/CMakeLists.txt">
+			<Option virtualFolder="CMake Files\"/>
+		</Unit>
+	</Project>
+</CodeBlocks_project_file>

cmake-build-debug/cmake_install.cmake

@@ -1,4 +1,4 @@
-# Install script for directory: /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp
+# Install script for directory: /home/massiveatoms/Desktop/studieproject/homebrew
 
 # Set the install prefix
 if(NOT DEFINED CMAKE_INSTALL_PREFIX)
@@ -12,7 +12,7 @@ if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
     string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
            CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
   else()
-    set(CMAKE_INSTALL_CONFIG_NAME "")
+    set(CMAKE_INSTALL_CONFIG_NAME "Debug")
   endif()
   message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
 endif()
@@ -37,9 +37,13 @@ if(NOT DEFINED CMAKE_CROSSCOMPILING)
   set(CMAKE_CROSSCOMPILING "FALSE")
 endif()
 
-if(NOT CMAKE_INSTALL_LOCAL_ONLY)
-  # Include the install script for each subdirectory.
-  include("/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/cmake_install.cmake")
-
+if(CMAKE_INSTALL_COMPONENT)
+  set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
 endif()
 
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+file(WRITE "/home/massiveatoms/Desktop/studieproject/homebrew/cmake-build-debug/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")

main.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <unordered_map>
+#include <functional>
+#include <fstream>
+
+#include "./src/includes/aggregate_tests.h"
+
+
+
+
+// typedef std::unordered_map<int,int> map;
+// we can use ^ to switch the map implementations to that
+// we can add some cli handling so we can specify which maps to tests (or all)
+int main() {
+    time_point<steady_clock> start_test = steady_clock::now();
+    string_test(std::unordered_map<std::string, std::string>{}, 1); // process gets killed for sizes >35000
+    int_test(std::unordered_map<int, int>{}, 1);
+    time_point<steady_clock> end_test = steady_clock::now();
+    std::cout << "1 run all tests 1 map: " << duration_cast<minutes>(end_test-start_test).count() << " minutes";
+    // test takes 52 mins for 10 runs for one hashmap
+    // so it'll take ~3 hours per map if we want 30 runs per test
+    /* if the other maps have about the same operation times ************
+
+    // maps to benchmark:
+    1. Google dense_hash_map
+    2. Google sparse_hash_map
+    3. folly F14ValueMap
+    4. folly F14NodeMap
+    5. Tessil/ordered-map
+    6. Tessil/array-hash
+    7. Tessil/hopscotch-map
+    8. Tessil/sparse-map/
+    9. abseil node_hash_map
+    10. abseil flat_hash_map
+    11. Glib GHashTable
+    12. Boost unordered_map
+    13. Qt QHash
+    14. skarupke/flat_hash_map
+    15. greg7mdp/sparsepp
+    16. greg7mdp /parallel-hashmap  (phmap::flat_hash_map and phmap::node_hash_map)
+    17. emilk/emilib emilib::hashmap
+    18. martinus robin_hood::unordered_node_map
+    19. martinus/robin-hood-hashing/
+    20. skarupke /flat_hash_map 
+    */
+    
+}

src/clang-format

@@ -1,62 +0,0 @@
----
-BasedOnStyle: WebKit
-AccessModifierOffset: '0'
-AlignAfterOpenBracket: Align
-AlignConsecutiveMacros: 'true'
-AlignConsecutiveAssignments: 'true'
-AlignEscapedNewlines: Left
-AlignTrailingComments: 'true'
-AllowAllArgumentsOnNextLine: 'true'
-AllowAllConstructorInitializersOnNextLine: 'true'
-AllowAllParametersOfDeclarationOnNextLine: 'true'
-AllowShortBlocksOnASingleLine: 'true'
-AllowShortCaseLabelsOnASingleLine: 'true'
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: Never
-AlwaysBreakTemplateDeclarations: 'Yes'
-BinPackArguments: 'false'
-BinPackParameters: 'false'
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Stroustrup
-BreakBeforeTernaryOperators: 'false'
-BreakConstructorInitializers: AfterColon
-BreakInheritanceList: AfterColon
-BreakStringLiterals: 'true'
-ColumnLimit: '100'
-CompactNamespaces: 'true'
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-ConstructorInitializerIndentWidth: '4'
-ContinuationIndentWidth: '4'
-Cpp11BracedListStyle: 'true'
-DerivePointerAlignment: 'false'
-DisableFormat: 'false'
-FixNamespaceComments: 'true'
-IncludeBlocks: Merge
-IndentCaseLabels: 'true'
-IndentWidth: '4'
-IndentWrappedFunctionNames: 'false'
-KeepEmptyLinesAtTheStartOfBlocks: 'true'
-Language: Cpp
-NamespaceIndentation: None
-PointerAlignment: Left
-ReflowComments: 'true'
-SortIncludes: 'true'
-SortUsingDeclarations: 'true'
-SpaceAfterCStyleCast: 'true'
-SpaceAfterLogicalNot: 'false'
-SpaceAfterTemplateKeyword: 'false'
-SpaceBeforeAssignmentOperators: 'true'
-SpaceBeforeCpp11BracedList: 'true'
-SpaceBeforeCtorInitializerColon: 'false'
-SpaceBeforeInheritanceColon: 'false'
-SpaceBeforeParens: ControlStatements
-SpaceBeforeRangeBasedForLoopColon: 'true'
-SpacesInAngles: 'false'
-SpacesInCStyleCastParentheses: 'false'
-SpacesInContainerLiterals: 'false'
-SpacesInParentheses: 'false'
-SpacesInSquareBrackets: 'false'
-Standard: Cpp11
-UseTab: ForContinuationAndIndentation
-
-...

src/generator.cpp

@@ -1,28 +1,28 @@
  
-#include "./includes/generator.h" // imports a generator to be used for the functions
+#include "./includes/generator.h"
+
 
-// generates string to be used as a key
 std::string gen_string() { // 90^size posibilities
     std::string randomstring;
     for (int i = 0; i < 5; ++i) {
-        randomstring += singlechar(generator);
-    }
-    return randomstring;
-}
-// gen strings that dont exist in the hashmap
-std::string gen_unsuccesfull_string() { // 90^size posibilities
-    std::string randomstring;
-    for (int i = 0; i < 4; ++i) {
-        randomstring += singlechar(generator);//
+        randomstring += gen_char(generator);
     }
     return randomstring;
 }
 
-// gen integers to be used as keys
-int gen_int() {
-    return insert_int(generator);
+std::string gen_unsuccesfull_string() { // 90^size posibilities
+    std::string randomstring;
+    for (int i = 0; i < 4; ++i) {
+        randomstring += gen_char(generator);
+    }
+    return randomstring;
 }
-//gen ints that don't exist in the hashmap
-int gen_unsuccesfull_int() {
-    return noninsert_int(generator);
+
+
+int gen_int(){
+    return gen_insert_int(generator);
+}
+
+int gen_unsuccesfull_int(){
+    return gen_noninsert_int(generator);
 }

src/includes/3thparty/abseil-cpp

@@ -1 +0,0 @@
-Subproject commit 24713a7036a81498334807fa5c7ad3cb7c643711

src/includes/3thparty/emilib/hash_map.hpp

@@ -1,666 +0,0 @@
-// By Emil Ernerfeldt 2014-2017
-// LICENSE:
-//   This software is dual-licensed to the public domain and under the following
-//   license: you are granted a perpetual, irrevocable license to copy, modify,
-//   publish, and distribute this file as you see fit.
-
-#pragma once
-
-#include <cstdlib>
-#include <iterator>
-#include <utility>
-
-#include "loguru.hpp"
-
-namespace emilib {
-
-/// like std::equal_to but no need to #include <functional>
-template<typename T>
-struct HashMapEqualTo
-{
-	constexpr bool operator()(const T& lhs, const T& rhs) const
-	{
-		return lhs == rhs;
-	}
-};
-
-/// A cache-friendly hash table with open addressing, linear probing and power-of-two capacity
-template <typename KeyT, typename ValueT, typename HashT = std::hash<KeyT>, typename EqT = HashMapEqualTo<KeyT>>
-class HashMap
-{
-private:
-	using MyType = HashMap<KeyT, ValueT, HashT, EqT>;
-
-	using PairT = std::pair<KeyT, ValueT>;
-public:
-	using size_type       = size_t;
-	using value_type      = PairT;
-	using reference       = PairT&;
-	using const_reference = const PairT&;
-
-	class iterator
-	{
-	public:
-		using iterator_category = std::forward_iterator_tag;
-		using difference_type   = size_t;
-		using distance_type     = size_t;
-		using value_type        = std::pair<KeyT, ValueT>;
-		using pointer           = value_type*;
-		using reference         = value_type&;
-
-		iterator() { }
-
-		iterator(MyType* hash_map, size_t bucket) : _map(hash_map), _bucket(bucket)
-		{
-		}
-
-		iterator& operator++()
-		{
-			this->goto_next_element();
-			return *this;
-		}
-
-		iterator operator++(int)
-		{
-			size_t old_index = _bucket;
-			this->goto_next_element();
-			return iterator(_map, old_index);
-		}
-
-		reference operator*() const
-		{
-			return _map->_pairs[_bucket];
-		}
-
-		pointer operator->() const
-		{
-			return _map->_pairs + _bucket;
-		}
-
-		bool operator==(const iterator& rhs) const
-		{
-			DCHECK_EQ_F(_map, rhs._map);
-			return this->_bucket == rhs._bucket;
-		}
-
-		bool operator!=(const iterator& rhs) const
-		{
-			DCHECK_EQ_F(_map, rhs._map);
-			return this->_bucket != rhs._bucket;
-		}
-
-	private:
-		void goto_next_element()
-		{
-			DCHECK_LT_F(_bucket, _map->_num_buckets);
-			do {
-				_bucket++;
-			} while (_bucket < _map->_num_buckets && _map->_states[_bucket] != State::FILLED);
-		}
-
-	//private:
-	//	friend class MyType;
-	public:
-		MyType* _map;
-		size_t  _bucket;
-	};
-
-	class const_iterator
-	{
-	public:
-		using iterator_category = std::forward_iterator_tag;
-		using difference_type   = size_t;
-		using distance_type     = size_t;
-		using value_type        = const std::pair<KeyT, ValueT>;
-		using pointer           = value_type*;
-		using reference         = value_type&;
-
-		const_iterator() { }
-
-		const_iterator(iterator proto) : _map(proto._map), _bucket(proto._bucket)
-		{
-		}
-
-		const_iterator(const MyType* hash_map, size_t bucket) : _map(hash_map), _bucket(bucket)
-		{
-		}
-
-		const_iterator& operator++()
-		{
-			this->goto_next_element();
-			return *this;
-		}
-
-		const_iterator operator++(int)
-		{
-			size_t old_index = _bucket;
-			this->goto_next_element();
-			return const_iterator(_map, old_index);
-		}
-
-		reference operator*() const
-		{
-			return _map->_pairs[_bucket];
-		}
-
-		pointer operator->() const
-		{
-			return _map->_pairs + _bucket;
-		}
-
-		bool operator==(const const_iterator& rhs) const
-		{
-			DCHECK_EQ_F(_map, rhs._map);
-			return this->_bucket == rhs._bucket;
-		}
-
-		bool operator!=(const const_iterator& rhs) const
-		{
-			DCHECK_EQ_F(_map, rhs._map);
-			return this->_bucket != rhs._bucket;
-		}
-
-	private:
-		void goto_next_element()
-		{
-			DCHECK_LT_F(_bucket, _map->_num_buckets);
-			do {
-				_bucket++;
-			} while (_bucket < _map->_num_buckets && _map->_states[_bucket] != State::FILLED);
-		}
-
-	//private:
-	//	friend class MyType;
-	public:
-		const MyType* _map;
-		size_t        _bucket;
-	};
-
-	// ------------------------------------------------------------------------
-
-	HashMap() = default;
-
-	HashMap(const HashMap& other)
-	{
-		reserve(other.size());
-		insert(other.cbegin(), other.cend());
-	}
-
-	HashMap(HashMap&& other)
-	{
-		*this = std::move(other);
-	}
-
-	HashMap& operator=(const HashMap& other)
-	{
-		clear();
-		reserve(other.size());
-		insert(other.cbegin(), other.cend());
-		return *this;
-	}
-
-	void operator=(HashMap&& other)
-	{
-		this->swap(other);
-	}
-
-	~HashMap()
-	{
-		for (size_t bucket=0; bucket<_num_buckets; ++bucket) {
-			if (_states[bucket] == State::FILLED) {
-				_pairs[bucket].~PairT();
-			}
-		}
-		free(_states);
-		free(_pairs);
-	}
-
-	void swap(HashMap& other)
-	{
-		std::swap(_hasher,           other._hasher);
-		std::swap(_eq,               other._eq);
-		std::swap(_states,           other._states);
-		std::swap(_pairs,            other._pairs);
-		std::swap(_num_buckets,      other._num_buckets);
-		std::swap(_num_filled,       other._num_filled);
-		std::swap(_max_probe_length, other._max_probe_length);
-		std::swap(_mask,             other._mask);
-	}
-
-	// -------------------------------------------------------------
-
-	iterator begin()
-	{
-		size_t bucket = 0;
-		while (bucket<_num_buckets && _states[bucket] != State::FILLED) {
-			++bucket;
-		}
-		return iterator(this, bucket);
-	}
-
-	const_iterator cbegin() const
-	{
-		size_t bucket = 0;
-		while (bucket<_num_buckets && _states[bucket] != State::FILLED) {
-			++bucket;
-		}
-		return const_iterator(this, bucket);
-	}
-
-	const_iterator begin() const
-	{
-		return cbegin();
-	}
-
-	iterator end()
-	{
-		return iterator(this, _num_buckets);
-	}
-
-	const_iterator cend() const
-	{
-		return const_iterator(this, _num_buckets);
-	}
-
-	const_iterator end() const
-	{
-		return cend();
-	}
-
-	size_t size() const
-	{
-		return _num_filled;
-	}
-
-	bool empty() const
-	{
-		return _num_filled==0;
-	}
-
-	// Returns the number of buckets.
-	size_t bucket_count() const
-	{
-		return _num_buckets;
-	}
-
-	/// Returns average number of elements per bucket.
-	float load_factor() const
-	{
-		return static_cast<float>(_num_filled) / static_cast<float>(_num_buckets);
-	}
-
-	// ------------------------------------------------------------
-
-	template<typename KeyLike>
-	iterator find(const KeyLike& key)
-	{
-		auto bucket = this->find_filled_bucket(key);
-		if (bucket == (size_t)-1) {
-			return this->end();
-		}
-		return iterator(this, bucket);
-	}
-
-	template<typename KeyLike>
-	const_iterator find(const KeyLike& key) const
-	{
-		auto bucket = this->find_filled_bucket(key);
-		if (bucket == (size_t)-1)
-		{
-			return this->end();
-		}
-		return const_iterator(this, bucket);
-	}
-
-	template<typename KeyLike>
-	bool contains(const KeyLike& k) const
-	{
-		return find_filled_bucket(k) != (size_t)-1;
-	}
-
-	template<typename KeyLike>
-	size_t count(const KeyLike& k) const
-	{
-		return find_filled_bucket(k) != (size_t)-1 ? 1 : 0;
-	}
-
-	/// Returns the matching ValueT or nullptr if k isn't found.
-	template<typename KeyLike>
-	ValueT* try_get(const KeyLike& k)
-	{
-		auto bucket = find_filled_bucket(k);
-		if (bucket != (size_t)-1) {
-			return &_pairs[bucket].second;
-		} else {
-			return nullptr;
-		}
-	}
-
-	/// Const version of the above
-	template<typename KeyLike>
-	const ValueT* try_get(const KeyLike& k) const
-	{
-		auto bucket = find_filled_bucket(k);
-		if (bucket != (size_t)-1) {
-			return &_pairs[bucket].second;
-		} else {
-			return nullptr;
-		}
-	}
-
-	/// Convenience function.
-	template<typename KeyLike>
-	const ValueT get_or_return_default(const KeyLike& k) const
-	{
-		const ValueT* ret = try_get(k);
-		if (ret) {
-			return *ret;
-		} else {
-			return ValueT();
-		}
-	}
-
-	// -----------------------------------------------------
-
-	/// Returns a pair consisting of an iterator to the inserted element
-	/// (or to the element that prevented the insertion)
-	/// and a bool denoting whether the insertion took place.
-	std::pair<iterator, bool> insert(const KeyT& key, const ValueT& value)
-	{
-		check_expand_need();
-
-		auto bucket = find_or_allocate(key);
-
-		if (_states[bucket] == State::FILLED) {
-			return { iterator(this, bucket), false };
-		} else {
-			_states[bucket] = State::FILLED;
-			new(_pairs + bucket) PairT(key, value);
-			_num_filled++;
-			return { iterator(this, bucket), true };
-		}
-	}
-
-	std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT>& p)
-	{
-		return insert(p.first, p.second);
-	}
-
-	void insert(const_iterator begin, const_iterator end)
-	{
-		// TODO: reserve space exactly once.
-		for (; begin != end; ++begin) {
-			insert(begin->first, begin->second);
-		}
-	}
-
-	/// Same as above, but contains(key) MUST be false
-	void insert_unique(KeyT&& key, ValueT&& value)
-	{
-		DCHECK_F(!contains(key));
-		check_expand_need();
-		auto bucket = find_empty_bucket(key);
-		_states[bucket] = State::FILLED;
-		new(_pairs + bucket) PairT(std::move(key), std::move(value));
-		_num_filled++;
-	}
-
-	void insert_unique(std::pair<KeyT, ValueT>&& p)
-	{
-		insert_unique(std::move(p.first), std::move(p.second));
-	}
-
-	void insert_or_assign(const KeyT& key, ValueT&& value)
-	{
-		check_expand_need();
-
-		auto bucket = find_or_allocate(key);
-
-		// Check if inserting a new value rather than overwriting an old entry
-		if (_states[bucket] == State::FILLED) {
-			_pairs[bucket].second = value;
-		} else {
-			_states[bucket] = State::FILLED;
-			new(_pairs + bucket) PairT(key, value);
-			_num_filled++;
-		}
-	}
-
-	/// Return the old value or ValueT() if it didn't exist.
-	ValueT set_get(const KeyT& key, const ValueT& new_value)
-	{
-		check_expand_need();
-
-		auto bucket = find_or_allocate(key);
-
-		// Check if inserting a new value rather than overwriting an old entry
-		if (_states[bucket] == State::FILLED) {
-			ValueT old_value = _pairs[bucket].second;
-			_pairs[bucket] = new_value.second;
-			return old_value;
-		} else {
-			_states[bucket] = State::FILLED;
-			new(_pairs + bucket) PairT(key, new_value);
-			_num_filled++;
-			return ValueT();
-		}
-	}
-
-	/// Like std::map<KeyT,ValueT>::operator[].
-	ValueT& operator[](const KeyT& key)
-	{
-		check_expand_need();
-
-		auto bucket = find_or_allocate(key);
-
-		/* Check if inserting a new value rather than overwriting an old entry */
-		if (_states[bucket] != State::FILLED) {
-			_states[bucket] = State::FILLED;
-			new(_pairs + bucket) PairT(key, ValueT());
-			_num_filled++;
-		}
-
-		return _pairs[bucket].second;
-	}
-
-	// -------------------------------------------------------
-
-	/// Erase an element from the hash table.
-	/// return false if element was not found
-	bool erase(const KeyT& key)
-	{
-		auto bucket = find_filled_bucket(key);
-		if (bucket != (size_t)-1) {
-			_states[bucket] = State::ACTIVE;
-			_pairs[bucket].~PairT();
-			_num_filled -= 1;
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	/// Erase an element using an iterator.
-	/// Returns an iterator to the next element (or end()).
-	iterator erase(iterator it)
-	{
-		DCHECK_EQ_F(it._map, this);
-		DCHECK_LT_F(it._bucket, _num_buckets);
-		_states[it._bucket] = State::ACTIVE;
-		_pairs[it._bucket].~PairT();
-		_num_filled -= 1;
-		return ++it;
-	}
-
-	/// Remove all elements, keeping full capacity.
-	void clear()
-	{
-		for (size_t bucket=0; bucket<_num_buckets; ++bucket) {
-			if (_states[bucket] == State::FILLED) {
-				_states[bucket] = State::INACTIVE;
-				_pairs[bucket].~PairT();
-			}
-		}
-		_num_filled = 0;
-		_max_probe_length = -1;
-	}
-
-	/// Make room for this many elements
-	void reserve(size_t num_elems)
-	{
-		size_t required_buckets = num_elems + num_elems/2 + 1;
-		if (required_buckets <= _num_buckets) {
-			return;
-		}
-		size_t num_buckets = 4;
-		while (num_buckets < required_buckets) { num_buckets *= 2; }
-
-		auto new_states = (State*)malloc(num_buckets * sizeof(State));
-		auto new_pairs  = (PairT*)malloc(num_buckets * sizeof(PairT));
-
-		if (!new_states || !new_pairs) {
-			free(new_states);
-			free(new_pairs);
-			throw std::bad_alloc();
-		}
-
-		//auto old_num_filled  = _num_filled;
-		auto old_num_buckets = _num_buckets;
-		auto old_states      = _states;
-		auto old_pairs       = _pairs;
-
-		_num_filled  = 0;
-		_num_buckets = num_buckets;
-		_mask        = _num_buckets - 1;
-		_states      = new_states;
-		_pairs       = new_pairs;
-
-		std::fill_n(_states, num_buckets, State::INACTIVE);
-
-		_max_probe_length = -1;
-
-		for (size_t src_bucket=0; src_bucket<old_num_buckets; src_bucket++) {
-			if (old_states[src_bucket] == State::FILLED) {
-				auto& src_pair = old_pairs[src_bucket];
-
-				auto dst_bucket = find_empty_bucket(src_pair.first);
-				DCHECK_NE_F(dst_bucket, (size_t)-1);
-				DCHECK_NE_F(_states[dst_bucket], State::FILLED);
-				_states[dst_bucket] = State::FILLED;
-				new(_pairs + dst_bucket) PairT(std::move(src_pair));
-				_num_filled += 1;
-
-				src_pair.~PairT();
-			}
-		}
-
-		//DCHECK_EQ_F(old_num_filled, _num_filled);
-
-		free(old_states);
-		free(old_pairs);
-	}
-
-private:
-	// Can we fit another element?
-	void check_expand_need()
-	{
-		reserve(_num_filled + 1);
-	}
-
-	// Find the bucket with this key, or return (size_t)-1
-	template<typename KeyLike>
-	size_t find_filled_bucket(const KeyLike& key) const
-	{
-		if (empty()) { return (size_t)-1; } // Optimization
-
-		auto hash_value = _hasher(key);
-		for (int offset=0; offset<=_max_probe_length; ++offset) {
-			auto bucket = (hash_value + offset) & _mask;
-			if (_states[bucket] == State::FILLED) {
-				if (_eq(_pairs[bucket].first, key)) {
-					return bucket;
-				}
-			} else if (_states[bucket] == State::INACTIVE) {
-				return (size_t)-1; // End of the chain!
-			}
-		}
-		return (size_t)-1;
-	}
-
-	// Find the bucket with this key, or return a good empty bucket to place the key in.
-	// In the latter case, the bucket is expected to be filled.
-	size_t find_or_allocate(const KeyT& key)
-	{
-		auto hash_value = _hasher(key);
-		size_t hole = (size_t)-1;
-		int offset=0;
-		for (; offset<=_max_probe_length; ++offset) {
-			auto bucket = (hash_value + offset) & _mask;
-
-			if (_states[bucket] == State::FILLED) {
-				if (_eq(_pairs[bucket].first, key)) {
-					return bucket;
-				}
-			} else if (_states[bucket] == State::INACTIVE) {
-				return bucket;
-			} else {
-				// ACTIVE: keep searching
-				if (hole == (size_t)-1) {
-					hole = bucket;
-				}
-			}
-		}
-
-		// No key found - but maybe a hole for it
-
-		DCHECK_EQ_F(offset, _max_probe_length+1);
-
-		if (hole != (size_t)-1) {
-			return hole;
-		}
-
-		// No hole found within _max_probe_length
-		for (; ; ++offset) {
-			auto bucket = (hash_value + offset) & _mask;
-
-			if (_states[bucket] != State::FILLED) {
-				_max_probe_length = offset;
-				return bucket;
-			}
-		}
-	}
-
-	// key is not in this map. Find a place to put it.
-	size_t find_empty_bucket(const KeyT& key)
-	{
-		auto hash_value = _hasher(key);
-		for (int offset=0; ; ++offset) {
-			auto bucket = (hash_value + offset) & _mask;
-			if (_states[bucket] != State::FILLED) {
-				if (offset > _max_probe_length) {
-					_max_probe_length = offset;
-				}
-				return bucket;
-			}
-		}
-	}
-
-private:
-	enum class State : uint8_t
-	{
-		INACTIVE, // Never been touched
-		ACTIVE,   // Is inside a search-chain, but is empty
-		FILLED    // Is set with key/value
-	};
-
-	HashT   _hasher;
-	EqT     _eq;
-	State*  _states           = nullptr;
-	PairT*  _pairs            = nullptr;
-	size_t  _num_buckets      =  0;
-	size_t  _num_filled       =  0;
-	int     _max_probe_length = -1; // Our longest bucket-brigade is this long. ONLY when we have zero elements is this ever negative (-1).
-	size_t  _mask             = 0;  // _num_buckets minus one
-};
-
-} // namespace emilib

src/includes/3thparty/parallel_hashmap/conanfile.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from conans import ConanFile, tools
-import os
-
-class SparseppConan(ConanFile):
-    name = "parallel_hashmap"
-    version = "1.27"
-    description = "A header-only, very fast and memory-friendly hash map"
-    
-    # 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()

src/includes/3thparty/parallel_hashmap/meminfo.h

@@ -1,195 +0,0 @@
-#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

src/includes/3thparty/parallel_hashmap/phmap_bits.h

@@ -1,663 +0,0 @@
-#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)
-    // 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__)
-    // 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 int CountLeadingZeros32Slow(uint64_t n) {
-    int 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 int CountLeadingZeros32(uint32_t n) {
-#if defined(_MSC_VER)
-    unsigned long result = 0;  // NOLINT(runtime/int)
-    if (_BitScanReverse(&result, n)) {
-        return (int)(31 - result);
-    }
-    return 32;
-#elif defined(__GNUC__)
-    // 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 int CountTrailingZerosNonZero64Slow(uint64_t n) {
-    int 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 int CountTrailingZerosNonZero64(uint64_t n) {
-#if defined(_MSC_VER) && defined(_M_X64)
-    unsigned long result = 0;  // NOLINT(runtime/int)
-    _BitScanForward64(&result, n);
-    return (int)result;
-#elif defined(_MSC_VER)
-    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__)
-    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 int CountTrailingZerosNonZero32Slow(uint32_t n) {
-    int 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 int CountTrailingZerosNonZero32(uint32_t n) {
-#if defined(_MSC_VER)
-    unsigned long result = 0;  // NOLINT(runtime/int)
-    _BitScanForward(&result, n);
-    return (int)result;
-#elif defined(__GNUC__)
-    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_

src/includes/3thparty/parallel_hashmap/phmap_config.h

@@ -1,753 +0,0 @@
-#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 0
-#define PHMAP_VERSION_PATCH 0
-
-// 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
-
-// ----------------------------------------------------------------
-// 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(__clang__) && defined(__GNUC__) && defined(__GLIBCXX__) && \
-     (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) ||        \
-    defined(_MSC_VER)
-    #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__) &&                 \
-     (__GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ >= 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
-        #define PHMAP_HAVE_STD_STRING_VIEW 1
-    #endif
-#endif
-
-// #pragma message(PHMAP_VAR_NAME_VALUE(_MSVC_LANG))
-
-#if defined(_MSC_VER) && _MSC_VER >= 1910 && \
-    ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703) || __cplusplus >= 201703)
-    // #define PHMAP_HAVE_STD_ANY 1
-    #define PHMAP_HAVE_STD_OPTIONAL 1
-    #define PHMAP_HAVE_STD_VARIANT 1
-    #define PHMAP_HAVE_STD_STRING_VIEW 1
-#endif
-
-#if (defined(_MSVC_LANG) && _MSVC_LANG >= 201703) || __cplusplus >= 201703
-    #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
-
-
-// -----------------------------------------------------------------------------
-// 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
-    #ifdef __SSSE3__
-        #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 __cplusplus >= 201703 || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703)
-    #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_

src/includes/3thparty/parallel_hashmap/phmap_dump.h

@@ -1,227 +0,0 @@
-#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 container_internal {
-
-// ------------------------------------------------------------------------
-// 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>::dump(OutputArchive& ar) {
-    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
-                    "value_type should be trivially copyable");
-
-    if (!ar.dump(size_)) {
-        std::cerr << "Failed to dump size_" << std::endl;
-        return false;
-    }
-    if (size_ == 0) {
-        return true;
-    }
-    if (!ar.dump(capacity_)) {
-        std::cerr << "Failed to dump capacity_" << std::endl;
-        return false;
-    }
-    if (!ar.dump(reinterpret_cast<char*>(ctrl_),
-        sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1))) {
-
-        std::cerr << "Failed to dump ctrl_" << std::endl;
-        return false;
-    }
-    if (!ar.dump(reinterpret_cast<char*>(slots_),
-                    sizeof(slot_type) * capacity_)) {
-        std::cerr << "Failed to dump slot_" << std::endl;
-        return false;
-    }
-    return true;
-}
-
-template <class Policy, class Hash, class Eq, class Alloc>
-template<typename InputArchive>
-bool raw_hash_set<Policy, Hash, Eq, Alloc>::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
-    if (!ar.load(&size_)) {
-        std::cerr << "Failed to load size_" << std::endl;
-        return false;
-    }
-    if (size_ == 0) {
-        return true;
-    }
-    if (!ar.load(&capacity_)) {
-        std::cerr << "Failed to load capacity_" << std::endl;
-        return false;
-    }
-
-    // allocate memory for ctrl_ and slots_
-    initialize_slots();
-    if (!ar.load(reinterpret_cast<char*>(ctrl_),
-        sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1))) {
-        std::cerr << "Failed to load ctrl" << std::endl;
-        return false;
-    }
-    if (!ar.load(reinterpret_cast<char*>(slots_),
-                    sizeof(slot_type) * capacity_)) {
-        std::cerr << "Failed to load slot" << std::endl;
-        return false;
-    }
-    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>::dump(OutputArchive& ar) {
-    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
-                    "value_type should be trivially copyable");
-
-    if (! ar.dump(subcnt())) {
-        std::cerr << "Failed to dump meta!" << std::endl;
-        return false;
-    }
-    for (size_t i = 0; i < sets_.size(); ++i) {
-        auto& inner = sets_[i];
-        typename Lockable::UniqueLock m(const_cast<Inner&>(inner));
-        if (!inner.set_.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>::load(InputArchive& ar) {
-    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
-                    "value_type should be trivially copyable");
-
-    size_t submap_count = 0;
-    if (!ar.load(&submap_count)) {
-        std::cerr << "Failed to load submap count!" << std::endl;
-        return false;
-    }
-
-    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_.load(ar)) {
-            std::cerr << "Failed to load submap " << i << std::endl;
-            return false;
-        }
-    }
-    return true;
-}
-} // namespace container_internal
-
-
-
-// ------------------------------------------------------------------------
-// BinaryArchive
-//       File is closed when archive object is destroyed
-// ------------------------------------------------------------------------
-
-// ------------------------------------------------------------------------
-// ------------------------------------------------------------------------
-class BinaryOutputArchive {
-public:
-    BinaryOutputArchive(const char *file_path) {
-        ofs_.open(file_path, std::ios_base::binary);
-    }
-
-    bool dump(const char *p, size_t sz) {
-        ofs_.write(p, sz);
-        return true;
-    }
-
-    template<typename V>
-    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
-    dump(const V& v) {
-        ofs_.write(reinterpret_cast<const char *>(&v), sizeof(V));
-        return true;
-    }
-
-private:
-    std::ofstream ofs_;
-};
-
-
-class BinaryInputArchive {
-public:
-    BinaryInputArchive(const char * file_path) {
-        ifs_.open(file_path, std::ios_base::binary);
-    }
-
-    bool load(char* p, size_t sz) {
-        ifs_.read(p, sz);
-        return true;
-    }
-
-    template<typename V>
-    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
-    load(V* v) {
-        ifs_.read(reinterpret_cast<char *>(v), sizeof(V));
-        return true;
-    }
-
-private:
-    std::ifstream ifs_;
-};
-
-} // namespace phmap
-
-#endif // phmap_dump_h_guard_

src/includes/3thparty/parallel_hashmap/phmap_fwd_decl.h

@@ -1,154 +0,0 @@
-#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)
-    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 container_internal {
-
-        // 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 container_internal::HashEq<T>::Hash;
-
-        template <class T>
-        using hash_default_eq = typename container_internal::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 container_internal
-
-    // ------------- forward declarations for hash containers ----------------------------------
-    template <class T, 
-              class Hash  = phmap::container_internal::hash_default_hash<T>,
-              class Eq    = phmap::container_internal::hash_default_eq<T>,
-              class Alloc = phmap::container_internal::Allocator<T>>  // alias for std::allocator
-        class flat_hash_set;
-
-    template <class K, class V,
-              class Hash  = phmap::container_internal::hash_default_hash<K>,
-              class Eq    = phmap::container_internal::hash_default_eq<K>,
-              class Alloc = phmap::container_internal::Allocator<
-                            phmap::container_internal::Pair<const K, V>>> // alias for std::allocator
-        class flat_hash_map;
-    
-    template <class T, 
-              class Hash  = phmap::container_internal::hash_default_hash<T>,
-              class Eq    = phmap::container_internal::hash_default_eq<T>,
-              class Alloc = phmap::container_internal::Allocator<T>> // alias for std::allocator
-        class node_hash_set;
-
-    template <class Key, class Value,
-              class Hash  = phmap::container_internal::hash_default_hash<Key>,
-              class Eq    = phmap::container_internal::hash_default_eq<Key>,
-              class Alloc = phmap::container_internal::Allocator<
-                            phmap::container_internal::Pair<const Key, Value>>> // alias for std::allocator
-        class node_hash_map;
-
-    template <class T,
-              class Hash  = phmap::container_internal::hash_default_hash<T>,
-              class Eq    = phmap::container_internal::hash_default_eq<T>,
-              class Alloc = phmap::container_internal::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::container_internal::hash_default_hash<K>,
-              class Eq    = phmap::container_internal::hash_default_eq<K>,
-              class Alloc = phmap::container_internal::Allocator<
-                            phmap::container_internal::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::container_internal::hash_default_hash<T>,
-              class Eq    = phmap::container_internal::hash_default_eq<T>,
-              class Alloc = phmap::container_internal::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::container_internal::hash_default_hash<Key>,
-              class Eq    = phmap::container_internal::hash_default_eq<Key>,
-              class Alloc = phmap::container_internal::Allocator<
-                            phmap::container_internal::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::container_internal::Pair<const Key, Value>>>
-        class btree_map;
-    
-    template <typename Key, typename Value, typename Compare = phmap::Less<Key>,
-              typename Alloc = phmap::Allocator<phmap::container_internal::Pair<const Key, Value>>>
-        class btree_multimap;
-
-}  // namespace phmap
-
-
-#ifdef _MSC_VER
-     #pragma warning(pop)  
-#endif
-
-#endif // phmap_fwd_decl_h_guard_

src/includes/3thparty/parallel_hashmap/phmap_utils.h

@@ -1,370 +0,0 @@
-#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"
-
-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<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_)
-    namespace absl { template <class T> struct Hash; };
-    template <class T> using Hash = absl::Hash<T>;
-#else
-// ---------------------------------------------------------------
-//               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 T>
-struct Hash<T *>
-{
-    inline size_t operator()(const T *val) const noexcept
-    {
-        return static_cast<size_t>(reinterpret_cast<const uintptr_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); }
-};
-
-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); }
-};
-
-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
-
-template <class H, int sz> struct Combiner
-{
-    H operator()(H seed, size_t value);
-};
-
-template <class H> struct Combiner<H, 4>
-{
-    H operator()(H seed, size_t value)
-    {
-        return seed ^ (value + 0x9e3779b9 + (seed << 6) + (seed >> 2));
-    }
-};
-
-template <class H> struct Combiner<H, 8>
-{
-    H operator()(H seed, size_t value)
-    {
-        return seed ^ (value + size_t(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2));
-    }
-};
-
-// 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 {
-        return _hash_helper(t);
-    }
-
-private:
-    template<size_t I = 0, class ...P>
-        typename std::enable_if<I == sizeof...(P), size_t>::type
-        _hash_helper(const std::tuple<P...> &) const noexcept { return 0; }
-
-    template<size_t I = 0, class ...P>
-    typename std::enable_if<I < sizeof...(P), size_t>::type
-    _hash_helper(const std::tuple<P...> &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;
-        return Combiner<size_t, sizeof(size_t)>()(
-            phmap::Hash<el_type>()(el),  _hash_helper<I + 1>(t));
-    }
-};
-
-
-#endif
-
-
-}  // namespace phmap
-
-#ifdef _MSC_VER
-     #pragma warning(pop)  
-#endif
-
-#endif // phmap_utils_h_guard_

src/includes/3thparty/skarupke

@@ -1 +0,0 @@
-Subproject commit 2c4687431f978f02a3780e24b8b701d22aa32d9c

src/includes/3thparty/sparsehash/dense_hash_map

@@ -1,369 +0,0 @@
-// Copyright (c) 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ----
-//
-// This is just a very thin wrapper over densehashtable.h, just
-// like sgi stl's stl_hash_map is a very thin wrapper over
-// stl_hashtable.  The major thing we define is operator[], because
-// we have a concept of a data_type which stl_hashtable doesn't
-// (it only has a key and a value).
-//
-// NOTE: this is exactly like sparse_hash_map.h, with the word
-// "sparse" replaced by "dense", except for the addition of
-// set_empty_key().
-//
-//   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
-//
-// Otherwise your program will die in mysterious ways.  (Note if you
-// use the constructor that takes an InputIterator range, you pass in
-// the empty key in the constructor, rather than after.  As a result,
-// this constructor differs from the standard STL version.)
-//
-// In other respects, we adhere mostly to the STL semantics for
-// hash-map.  One important exception is that insert() may invalidate
-// iterators entirely -- STL semantics are that insert() may reorder
-// iterators, but they all still refer to something valid in the
-// hashtable.  Not so for us.  Likewise, insert() may invalidate
-// pointers into the hashtable.  (Whether insert invalidates iterators
-// and pointers depends on whether it results in a hashtable resize).
-// On the plus side, delete() doesn't invalidate iterators or pointers
-// at all, or even change the ordering of elements.
-//
-// Here are a few "power user" tips:
-//
-//    1) set_deleted_key():
-//         If you want to use erase() you *must* call set_deleted_key(),
-//         in addition to set_empty_key(), after construction.
-//         The deleted and empty keys must differ.
-//
-//    2) resize(0):
-//         When an item is deleted, its memory isn't freed right
-//         away.  This allows you to iterate over a hashtable,
-//         and call erase(), without invalidating the iterator.
-//         To force the memory to be freed, call resize(0).
-//         For tr1 compatibility, this can also be called as rehash(0).
-//
-//    3) min_load_factor(0.0)
-//         Setting the minimum load factor to 0.0 guarantees that
-//         the hash table will never shrink.
-//
-// Roughly speaking:
-//   (1) dense_hash_map: fastest, uses the most memory unless entries are small
-//   (2) sparse_hash_map: slowest, uses the least memory
-//   (3) hash_map / unordered_map (STL): in the middle
-//
-// Typically I use sparse_hash_map when I care about space and/or when
-// I need to save the hashtable on disk.  I use hash_map otherwise.  I
-// don't personally use dense_hash_set ever; some people use it for
-// small sets with lots of lookups.
-//
-// - dense_hash_map has, typically, about 78% memory overhead (if your
-//   data takes up X bytes, the hash_map uses .78X more bytes in overhead).
-// - sparse_hash_map has about 4 bits overhead per entry.
-// - sparse_hash_map can be 3-7 times slower than the others for lookup and,
-//   especially, inserts.  See time_hash_map.cc for details.
-//
-// See /usr/(local/)?doc/sparsehash-*/dense_hash_map.html
-// for information about how to use this class.
-
-#ifndef _DENSE_HASH_MAP_H_
-#define _DENSE_HASH_MAP_H_
-
-#include "./internal/sparseconfig.h"
-#include <algorithm>                        // needed by stl_alloc
-#include <functional>                       // for equal_to<>, select1st<>, etc
-#include <memory>                           // for alloc
-#include <utility>                          // for pair<>
-#include "./internal/densehashtable.h"        // IWYU pragma: export
-#include "./internal/libc_allocator_with_realloc.h"
-#include HASH_FUN_H                 // for hash<>
-_START_GOOGLE_NAMESPACE_
-
-template <class Key, class T,
-          class HashFcn = SPARSEHASH_HASH<Key>,   // defined in sparseconfig.h
-          class EqualKey = std::equal_to<Key>,
-          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T> > >
-class dense_hash_map {
- private:
-  // Apparently select1st is not stl-standard, so we define our own
-  struct SelectKey {
-    typedef const Key& result_type;
-    const Key& operator()(const std::pair<const Key, T>& p) const {
-      return p.first;
-    }
-  };
-  struct SetKey {
-    void operator()(std::pair<const Key, T>* value, const Key& new_key) const {
-      *const_cast<Key*>(&value->first) = new_key;
-      // It would be nice to clear the rest of value here as well, in
-      // case it's taking up a lot of memory.  We do this by clearing
-      // the value.  This assumes T has a zero-arg constructor!
-      value->second = T();
-    }
-  };
-  // For operator[].
-  struct DefaultValue {
-    std::pair<const Key, T> operator()(const Key& key) {
-      return std::make_pair(key, T());
-    }
-  };
-
-  // The actual data
-  typedef dense_hashtable<std::pair<const Key, T>, Key, HashFcn, SelectKey,
-                          SetKey, EqualKey, Alloc> ht;
-  ht rep;
-
- public:
-  typedef typename ht::key_type key_type;
-  typedef T data_type;
-  typedef T mapped_type;
-  typedef typename ht::value_type value_type;
-  typedef typename ht::hasher hasher;
-  typedef typename ht::key_equal key_equal;
-  typedef Alloc allocator_type;
-
-  typedef typename ht::size_type size_type;
-  typedef typename ht::difference_type difference_type;
-  typedef typename ht::pointer pointer;
-  typedef typename ht::const_pointer const_pointer;
-  typedef typename ht::reference reference;
-  typedef typename ht::const_reference const_reference;
-
-  typedef typename ht::iterator iterator;
-  typedef typename ht::const_iterator const_iterator;
-  typedef typename ht::local_iterator local_iterator;
-  typedef typename ht::const_local_iterator const_local_iterator;
-
-  // Iterator functions
-  iterator begin()                               { return rep.begin(); }
-  iterator end()                                 { return rep.end(); }
-  const_iterator begin() const                   { return rep.begin(); }
-  const_iterator end() const                     { return rep.end(); }
-
-
-  // These come from tr1's unordered_map. For us, a bucket has 0 or 1 elements.
-  local_iterator begin(size_type i)              { return rep.begin(i); }
-  local_iterator end(size_type i)                { return rep.end(i); }
-  const_local_iterator begin(size_type i) const  { return rep.begin(i); }
-  const_local_iterator end(size_type i) const    { return rep.end(i); }
-
-  // Accessor functions
-  allocator_type get_allocator() const           { return rep.get_allocator(); }
-  hasher hash_funct() const                      { return rep.hash_funct(); }
-  hasher hash_function() const                   { return hash_funct(); }
-  key_equal key_eq() const                       { return rep.key_eq(); }
-
-
-  // Constructors
-  explicit dense_hash_map(size_type expected_max_items_in_table = 0,
-                          const hasher& hf = hasher(),
-                          const key_equal& eql = key_equal(),
-                          const allocator_type& alloc = allocator_type())
-    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
-  }
-
-  template <class InputIterator>
-  dense_hash_map(InputIterator f, InputIterator l,
-                 const key_type& empty_key_val,
-                 size_type expected_max_items_in_table = 0,
-                 const hasher& hf = hasher(),
-                 const key_equal& eql = key_equal(),
-                 const allocator_type& alloc = allocator_type())
-    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
-    set_empty_key(empty_key_val);
-    rep.insert(f, l);
-  }
-  // We use the default copy constructor
-  // We use the default operator=()
-  // We use the default destructor
-
-  void clear()                        { rep.clear(); }
-  // This clears the hash map without resizing it down to the minimum
-  // bucket count, but rather keeps the number of buckets constant
-  void clear_no_resize()              { rep.clear_no_resize(); }
-  void swap(dense_hash_map& hs)       { rep.swap(hs.rep); }
-
-
-  // Functions concerning size
-  size_type size() const              { return rep.size(); }
-  size_type max_size() const          { return rep.max_size(); }
-  bool empty() const                  { return rep.empty(); }
-  size_type bucket_count() const      { return rep.bucket_count(); }
-  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
-
-  // These are tr1 methods.  bucket() is the bucket the key is or would be in.
-  size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
-  size_type bucket(const key_type& key) const { return rep.bucket(key); }
-  float load_factor() const {
-    return size() * 1.0f / bucket_count();
-  }
-  float max_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return grow;
-  }
-  void max_load_factor(float new_grow) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(shrink, new_grow);
-  }
-  // These aren't tr1 methods but perhaps ought to be.
-  float min_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return shrink;
-  }
-  void min_load_factor(float new_shrink) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(new_shrink, grow);
-  }
-  // Deprecated; use min_load_factor() or max_load_factor() instead.
-  void set_resizing_parameters(float shrink, float grow) {
-    rep.set_resizing_parameters(shrink, grow);
-  }
-
-  void resize(size_type hint)         { rep.resize(hint); }
-  void rehash(size_type hint)         { resize(hint); }      // the tr1 name
-
-  // Lookup routines
-  iterator find(const key_type& key)                 { return rep.find(key); }
-  const_iterator find(const key_type& key) const     { return rep.find(key); }
-
-  data_type& operator[](const key_type& key) {       // This is our value-add!
-    // If key is in the hashtable, returns find(key)->second,
-    // otherwise returns insert(value_type(key, T()).first->second.
-    // Note it does not create an empty T unless the find fails.
-    return rep.template find_or_insert<DefaultValue>(key).second;
-  }
-
-  size_type count(const key_type& key) const         { return rep.count(key); }
-
-  std::pair<iterator, iterator> equal_range(const key_type& key) {
-    return rep.equal_range(key);
-  }
-  std::pair<const_iterator, const_iterator> equal_range(const key_type& key)
-      const {
-    return rep.equal_range(key);
-  }
-
-
-  // Insertion routines
-  std::pair<iterator, bool> insert(const value_type& obj) {
-    return rep.insert(obj);
-  }
-  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
-    rep.insert(f, l);
-  }
-  void insert(const_iterator f, const_iterator l) {
-    rep.insert(f, l);
-  }
-  // Required for std::insert_iterator; the passed-in iterator is ignored.
-  iterator insert(iterator, const value_type& obj) {
-    return insert(obj).first;
-  }
-
-  // Deletion and empty routines
-  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
-  // value to identify deleted and empty buckets.  You can change the
-  // deleted key as time goes on, or get rid of it entirely to be insert-only.
-  void set_empty_key(const key_type& key)   {           // YOU MUST CALL THIS!
-    rep.set_empty_key(value_type(key, data_type()));    // rep wants a value
-  }
-  key_type empty_key() const {
-    return rep.empty_key().first;                       // rep returns a value
-  }
-
-  void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
-  void clear_deleted_key()                    { rep.clear_deleted_key(); }
-  key_type deleted_key() const                { return rep.deleted_key(); }
-
-  // These are standard
-  size_type erase(const key_type& key)               { return rep.erase(key); }
-  void erase(iterator it)                            { rep.erase(it); }
-  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
-
-
-  // Comparison
-  bool operator==(const dense_hash_map& hs) const    { return rep == hs.rep; }
-  bool operator!=(const dense_hash_map& hs) const    { return rep != hs.rep; }
-
-
-  // I/O -- this is an add-on for writing hash map to disk
-  //
-  // For maximum flexibility, this does not assume a particular
-  // file type (though it will probably be a FILE *).  We just pass
-  // the fp through to rep.
-
-  // If your keys and values are simple enough, you can pass this
-  // serializer to serialize()/unserialize().  "Simple enough" means
-  // value_type is a POD type that contains no pointers.  Note,
-  // however, we don't try to normalize endianness.
-  typedef typename ht::NopointerSerializer NopointerSerializer;
-
-  // serializer: a class providing operator()(OUTPUT*, const value_type&)
-  //    (writing value_type to OUTPUT).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
-  //    pointer to a class providing size_t Write(const void*, size_t),
-  //    which writes a buffer into a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully written.
-  //    Note basic_ostream<not_char> is not currently supported.
-  template <typename ValueSerializer, typename OUTPUT>
-  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
-    return rep.serialize(serializer, fp);
-  }
-
-  // serializer: a functor providing operator()(INPUT*, value_type*)
-  //    (reading from INPUT and into value_type).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
-  //    pointer to a class providing size_t Read(void*, size_t),
-  //    which reads into a buffer from a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully read.
-  //    Note basic_istream<not_char> is not currently supported.
-  // NOTE: Since value_type is std::pair<const Key, T>, ValueSerializer
-  // may need to do a const cast in order to fill in the key.
-  template <typename ValueSerializer, typename INPUT>
-  bool unserialize(ValueSerializer serializer, INPUT* fp) {
-    return rep.unserialize(serializer, fp);
-  }
-};
-
-// We need a global swap as well
-template <class Key, class T, class HashFcn, class EqualKey, class Alloc>
-inline void swap(dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,
-                 dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2) {
-  hm1.swap(hm2);
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif /* _DENSE_HASH_MAP_H_ */

src/includes/3thparty/sparsehash/dense_hash_set

@@ -1,338 +0,0 @@
-// Copyright (c) 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-//
-// This is just a very thin wrapper over densehashtable.h, just
-// like sgi stl's stl_hash_set is a very thin wrapper over
-// stl_hashtable.  The major thing we define is operator[], because
-// we have a concept of a data_type which stl_hashtable doesn't
-// (it only has a key and a value).
-//
-// This is more different from dense_hash_map than you might think,
-// because all iterators for sets are const (you obviously can't
-// change the key, and for sets there is no value).
-//
-// NOTE: this is exactly like sparse_hash_set.h, with the word
-// "sparse" replaced by "dense", except for the addition of
-// set_empty_key().
-//
-//   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
-//
-// Otherwise your program will die in mysterious ways.  (Note if you
-// use the constructor that takes an InputIterator range, you pass in
-// the empty key in the constructor, rather than after.  As a result,
-// this constructor differs from the standard STL version.)
-//
-// In other respects, we adhere mostly to the STL semantics for
-// hash-map.  One important exception is that insert() may invalidate
-// iterators entirely -- STL semantics are that insert() may reorder
-// iterators, but they all still refer to something valid in the
-// hashtable.  Not so for us.  Likewise, insert() may invalidate
-// pointers into the hashtable.  (Whether insert invalidates iterators
-// and pointers depends on whether it results in a hashtable resize).
-// On the plus side, delete() doesn't invalidate iterators or pointers
-// at all, or even change the ordering of elements.
-//
-// Here are a few "power user" tips:
-//
-//    1) set_deleted_key():
-//         If you want to use erase() you must call set_deleted_key(),
-//         in addition to set_empty_key(), after construction.
-//         The deleted and empty keys must differ.
-//
-//    2) resize(0):
-//         When an item is deleted, its memory isn't freed right
-//         away.  This allows you to iterate over a hashtable,
-//         and call erase(), without invalidating the iterator.
-//         To force the memory to be freed, call resize(0).
-//         For tr1 compatibility, this can also be called as rehash(0).
-//
-//    3) min_load_factor(0.0)
-//         Setting the minimum load factor to 0.0 guarantees that
-//         the hash table will never shrink.
-//
-// Roughly speaking:
-//   (1) dense_hash_set: fastest, uses the most memory unless entries are small
-//   (2) sparse_hash_set: slowest, uses the least memory
-//   (3) hash_set / unordered_set (STL): in the middle
-//
-// Typically I use sparse_hash_set when I care about space and/or when
-// I need to save the hashtable on disk.  I use hash_set otherwise.  I
-// don't personally use dense_hash_set ever; some people use it for
-// small sets with lots of lookups.
-//
-// - dense_hash_set has, typically, about 78% memory overhead (if your
-//   data takes up X bytes, the hash_set uses .78X more bytes in overhead).
-// - sparse_hash_set has about 4 bits overhead per entry.
-// - sparse_hash_set can be 3-7 times slower than the others for lookup and,
-//   especially, inserts.  See time_hash_map.cc for details.
-//
-// See /usr/(local/)?doc/sparsehash-*/dense_hash_set.html
-// for information about how to use this class.
-
-#ifndef _DENSE_HASH_SET_H_
-#define _DENSE_HASH_SET_H_
-
-#include <sparsehash/internal/sparseconfig.h>
-#include <algorithm>                        // needed by stl_alloc
-#include <functional>                       // for equal_to<>, select1st<>, etc
-#include <memory>                           // for alloc
-#include <utility>                          // for pair<>
-#include <sparsehash/internal/densehashtable.h>        // IWYU pragma: export
-#include <sparsehash/internal/libc_allocator_with_realloc.h>
-#include HASH_FUN_H                 // for hash<>
-_START_GOOGLE_NAMESPACE_
-
-template <class Value,
-          class HashFcn = SPARSEHASH_HASH<Value>,   // defined in sparseconfig.h
-          class EqualKey = std::equal_to<Value>,
-          class Alloc = libc_allocator_with_realloc<Value> >
-class dense_hash_set {
- private:
-  // Apparently identity is not stl-standard, so we define our own
-  struct Identity {
-    typedef const Value& result_type;
-    const Value& operator()(const Value& v) const { return v; }
-  };
-  struct SetKey {
-    void operator()(Value* value, const Value& new_key) const {
-      *value = new_key;
-    }
-  };
-
-  // The actual data
-  typedef dense_hashtable<Value, Value, HashFcn, Identity, SetKey,
-                          EqualKey, Alloc> ht;
-  ht rep;
-
- public:
-  typedef typename ht::key_type key_type;
-  typedef typename ht::value_type value_type;
-  typedef typename ht::hasher hasher;
-  typedef typename ht::key_equal key_equal;
-  typedef Alloc allocator_type;
-
-  typedef typename ht::size_type size_type;
-  typedef typename ht::difference_type difference_type;
-  typedef typename ht::const_pointer pointer;
-  typedef typename ht::const_pointer const_pointer;
-  typedef typename ht::const_reference reference;
-  typedef typename ht::const_reference const_reference;
-
-  typedef typename ht::const_iterator iterator;
-  typedef typename ht::const_iterator const_iterator;
-  typedef typename ht::const_local_iterator local_iterator;
-  typedef typename ht::const_local_iterator const_local_iterator;
-
-
-  // Iterator functions -- recall all iterators are const
-  iterator begin() const                  { return rep.begin(); }
-  iterator end() const                    { return rep.end(); }
-
-  // These come from tr1's unordered_set. For us, a bucket has 0 or 1 elements.
-  local_iterator begin(size_type i) const { return rep.begin(i); }
-  local_iterator end(size_type i) const   { return rep.end(i); }
-
-
-  // Accessor functions
-  allocator_type get_allocator() const    { return rep.get_allocator(); }
-  hasher hash_funct() const               { return rep.hash_funct(); }
-  hasher hash_function() const            { return hash_funct(); }  // tr1 name
-  key_equal key_eq() const                { return rep.key_eq(); }
-
-
-  // Constructors
-  explicit dense_hash_set(size_type expected_max_items_in_table = 0,
-                          const hasher& hf = hasher(),
-                          const key_equal& eql = key_equal(),
-                          const allocator_type& alloc = allocator_type())
-      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
-  }
-
-  template <class InputIterator>
-  dense_hash_set(InputIterator f, InputIterator l,
-                 const key_type& empty_key_val,
-                 size_type expected_max_items_in_table = 0,
-                 const hasher& hf = hasher(),
-                 const key_equal& eql = key_equal(),
-                 const allocator_type& alloc = allocator_type())
-      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
-    set_empty_key(empty_key_val);
-    rep.insert(f, l);
-  }
-  // We use the default copy constructor
-  // We use the default operator=()
-  // We use the default destructor
-
-  void clear()                        { rep.clear(); }
-  // This clears the hash set without resizing it down to the minimum
-  // bucket count, but rather keeps the number of buckets constant
-  void clear_no_resize()              { rep.clear_no_resize(); }
-  void swap(dense_hash_set& hs)       { rep.swap(hs.rep); }
-
-
-  // Functions concerning size
-  size_type size() const              { return rep.size(); }
-  size_type max_size() const          { return rep.max_size(); }
-  bool empty() const                  { return rep.empty(); }
-  size_type bucket_count() const      { return rep.bucket_count(); }
-  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
-
-  // These are tr1 methods.  bucket() is the bucket the key is or would be in.
-  size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
-  size_type bucket(const key_type& key) const { return rep.bucket(key); }
-  float load_factor() const {
-    return size() * 1.0f / bucket_count();
-  }
-  float max_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return grow;
-  }
-  void max_load_factor(float new_grow) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(shrink, new_grow);
-  }
-  // These aren't tr1 methods but perhaps ought to be.
-  float min_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return shrink;
-  }
-  void min_load_factor(float new_shrink) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(new_shrink, grow);
-  }
-  // Deprecated; use min_load_factor() or max_load_factor() instead.
-  void set_resizing_parameters(float shrink, float grow) {
-    rep.set_resizing_parameters(shrink, grow);
-  }
-
-  void resize(size_type hint)         { rep.resize(hint); }
-  void rehash(size_type hint)         { resize(hint); }     // the tr1 name
-
-  // Lookup routines
-  iterator find(const key_type& key) const           { return rep.find(key); }
-
-  size_type count(const key_type& key) const         { return rep.count(key); }
-
-  std::pair<iterator, iterator> equal_range(const key_type& key) const {
-    return rep.equal_range(key);
-  }
-
-
-  // Insertion routines
-  std::pair<iterator, bool> insert(const value_type& obj) {
-    std::pair<typename ht::iterator, bool> p = rep.insert(obj);
-    return std::pair<iterator, bool>(p.first, p.second);   // const to non-const
-  }
-  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
-    rep.insert(f, l);
-  }
-  void insert(const_iterator f, const_iterator l) {
-    rep.insert(f, l);
-  }
-  // Required for std::insert_iterator; the passed-in iterator is ignored.
-  iterator insert(iterator, const value_type& obj)   {
-    return insert(obj).first;
-  }
-
-  // Deletion and empty routines
-  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
-  // value to identify deleted and empty buckets.  You can change the
-  // deleted key as time goes on, or get rid of it entirely to be insert-only.
-  void set_empty_key(const key_type& key)     { rep.set_empty_key(key); }
-  key_type empty_key() const                  { return rep.empty_key(); }
-
-  void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
-  void clear_deleted_key()                    { rep.clear_deleted_key(); }
-  key_type deleted_key() const                { return rep.deleted_key(); }
-
-  // These are standard
-  size_type erase(const key_type& key)               { return rep.erase(key); }
-  void erase(iterator it)                            { rep.erase(it); }
-  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
-
-
-  // Comparison
-  bool operator==(const dense_hash_set& hs) const    { return rep == hs.rep; }
-  bool operator!=(const dense_hash_set& hs) const    { return rep != hs.rep; }
-
-
-  // I/O -- this is an add-on for writing metainformation to disk
-  //
-  // For maximum flexibility, this does not assume a particular
-  // file type (though it will probably be a FILE *).  We just pass
-  // the fp through to rep.
-
-  // If your keys and values are simple enough, you can pass this
-  // serializer to serialize()/unserialize().  "Simple enough" means
-  // value_type is a POD type that contains no pointers.  Note,
-  // however, we don't try to normalize endianness.
-  typedef typename ht::NopointerSerializer NopointerSerializer;
-
-  // serializer: a class providing operator()(OUTPUT*, const value_type&)
-  //    (writing value_type to OUTPUT).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
-  //    pointer to a class providing size_t Write(const void*, size_t),
-  //    which writes a buffer into a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully written.
-  //    Note basic_ostream<not_char> is not currently supported.
-  template <typename ValueSerializer, typename OUTPUT>
-  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
-    return rep.serialize(serializer, fp);
-  }
-
-  // serializer: a functor providing operator()(INPUT*, value_type*)
-  //    (reading from INPUT and into value_type).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
-  //    pointer to a class providing size_t Read(void*, size_t),
-  //    which reads into a buffer from a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully read.
-  //    Note basic_istream<not_char> is not currently supported.
-  template <typename ValueSerializer, typename INPUT>
-  bool unserialize(ValueSerializer serializer, INPUT* fp) {
-    return rep.unserialize(serializer, fp);
-  }
-};
-
-template <class Val, class HashFcn, class EqualKey, class Alloc>
-inline void swap(dense_hash_set<Val, HashFcn, EqualKey, Alloc>& hs1,
-                 dense_hash_set<Val, HashFcn, EqualKey, Alloc>& hs2) {
-  hs1.swap(hs2);
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif /* _DENSE_HASH_SET_H_ */

src/includes/3thparty/sparsehash/internal/hashtable-common.h

@@ -1,381 +0,0 @@
-// Copyright (c) 2010, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-//
-// Provides classes shared by both sparse and dense hashtable.
-//
-// sh_hashtable_settings has parameters for growing and shrinking
-// a hashtable.  It also packages zero-size functor (ie. hasher).
-//
-// Other functions and classes provide common code for serializing
-// and deserializing hashtables to a stream (such as a FILE*).
-
-#ifndef UTIL_GTL_HASHTABLE_COMMON_H_
-#define UTIL_GTL_HASHTABLE_COMMON_H_
-
-#include "./sparseconfig.h"
-#include <assert.h>
-#include <stdio.h>
-#include <stddef.h>                  // for size_t
-#include <iosfwd>
-#include <stdexcept>                 // For length_error
-
-_START_GOOGLE_NAMESPACE_
-
-template <bool> struct SparsehashCompileAssert { };
-#define SPARSEHASH_COMPILE_ASSERT(expr, msg) \
-  __attribute__((unused)) typedef SparsehashCompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
-
-namespace sparsehash_internal {
-
-// Adaptor methods for reading/writing data from an INPUT or OUPTUT
-// variable passed to serialize() or unserialize().  For now we
-// have implemented INPUT/OUTPUT for FILE*, istream*/ostream* (note
-// they are pointers, unlike typical use), or else a pointer to
-// something that supports a Read()/Write() method.
-//
-// For technical reasons, we implement read_data/write_data in two
-// stages.  The actual work is done in *_data_internal, which takes
-// the stream argument twice: once as a template type, and once with
-// normal type information.  (We only use the second version.)  We do
-// this because of how C++ picks what function overload to use.  If we
-// implemented this the naive way:
-//    bool read_data(istream* is, const void* data, size_t length);
-//    template<typename T> read_data(T* fp,  const void* data, size_t length);
-// C++ would prefer the second version for every stream type except
-// istream.  However, we want C++ to prefer the first version for
-// streams that are *subclasses* of istream, such as istringstream.
-// This is not possible given the way template types are resolved.  So
-// we split the stream argument in two, one of which is templated and
-// one of which is not.  The specialized functions (like the istream
-// version above) ignore the template arg and use the second, 'type'
-// arg, getting subclass matching as normal.  The 'catch-all'
-// functions (the second version above) use the template arg to deduce
-// the type, and use a second, void* arg to achieve the desired
-// 'catch-all' semantics.
-
-// ----- low-level I/O for FILE* ----
-
-template<typename Ignored>
-inline bool read_data_internal(Ignored*, FILE* fp,
-                               void* data, size_t length) {
-  return fread(data, length, 1, fp) == 1;
-}
-
-template<typename Ignored>
-inline bool write_data_internal(Ignored*, FILE* fp,
-                                const void* data, size_t length) {
-  return fwrite(data, length, 1, fp) == 1;
-}
-
-// ----- low-level I/O for iostream ----
-
-// We want the caller to be responsible for #including <iostream>, not
-// us, because iostream is a big header!  According to the standard,
-// it's only legal to delay the instantiation the way we want to if
-// the istream/ostream is a template type.  So we jump through hoops.
-template<typename ISTREAM>
-inline bool read_data_internal_for_istream(ISTREAM* fp,
-                                           void* data, size_t length) {
-  return fp->read(reinterpret_cast<char*>(data), length).good();
-}
-template<typename Ignored>
-inline bool read_data_internal(Ignored*, std::istream* fp,
-                               void* data, size_t length) {
-  return read_data_internal_for_istream(fp, data, length);
-}
-
-template<typename OSTREAM>
-inline bool write_data_internal_for_ostream(OSTREAM* fp,
-                                            const void* data, size_t length) {
-  return fp->write(reinterpret_cast<const char*>(data), length).good();
-}
-template<typename Ignored>
-inline bool write_data_internal(Ignored*, std::ostream* fp,
-                                const void* data, size_t length) {
-  return write_data_internal_for_ostream(fp, data, length);
-}
-
-// ----- low-level I/O for custom streams ----
-
-// The INPUT type needs to support a Read() method that takes a
-// buffer and a length and returns the number of bytes read.
-template <typename INPUT>
-inline bool read_data_internal(INPUT* fp, void*,
-                               void* data, size_t length) {
-  return static_cast<size_t>(fp->Read(data, length)) == length;
-}
-
-// The OUTPUT type needs to support a Write() operation that takes
-// a buffer and a length and returns the number of bytes written.
-template <typename OUTPUT>
-inline bool write_data_internal(OUTPUT* fp, void*,
-                                const void* data, size_t length) {
-  return static_cast<size_t>(fp->Write(data, length)) == length;
-}
-
-// ----- low-level I/O: the public API ----
-
-template <typename INPUT>
-inline bool read_data(INPUT* fp, void* data, size_t length) {
-  return read_data_internal(fp, fp, data, length);
-}
-
-template <typename OUTPUT>
-inline bool write_data(OUTPUT* fp, const void* data, size_t length) {
-  return write_data_internal(fp, fp, data, length);
-}
-
-// Uses read_data() and write_data() to read/write an integer.
-// length is the number of bytes to read/write (which may differ
-// from sizeof(IntType), allowing us to save on a 32-bit system
-// and load on a 64-bit system).  Excess bytes are taken to be 0.
-// INPUT and OUTPUT must match legal inputs to read/write_data (above).
-template <typename INPUT, typename IntType>
-bool read_bigendian_number(INPUT* fp, IntType* value, size_t length) {
-  *value = 0;
-  unsigned char byte;
-  // We require IntType to be unsigned or else the shifting gets all screwy.
-  SPARSEHASH_COMPILE_ASSERT(static_cast<IntType>(-1) > static_cast<IntType>(0),
-                            serializing_int_requires_an_unsigned_type);
-  for (size_t i = 0; i < length; ++i) {
-    if (!read_data(fp, &byte, sizeof(byte))) return false;
-    *value |= static_cast<IntType>(byte) << ((length - 1 - i) * 8);
-  }
-  return true;
-}
-
-template <typename OUTPUT, typename IntType>
-bool write_bigendian_number(OUTPUT* fp, IntType value, size_t length) {
-  unsigned char byte;
-  // We require IntType to be unsigned or else the shifting gets all screwy.
-  SPARSEHASH_COMPILE_ASSERT(static_cast<IntType>(-1) > static_cast<IntType>(0),
-                            serializing_int_requires_an_unsigned_type);
-  for (size_t i = 0; i < length; ++i) {
-    byte = (sizeof(value) <= length-1 - i)
-        ? 0 : static_cast<unsigned char>((value >> ((length-1 - i) * 8)) & 255);
-    if (!write_data(fp, &byte, sizeof(byte))) return false;
-  }
-  return true;
-}
-
-// If your keys and values are simple enough, you can pass this
-// serializer to serialize()/unserialize().  "Simple enough" means
-// value_type is a POD type that contains no pointers.  Note,
-// however, we don't try to normalize endianness.
-// This is the type used for NopointerSerializer.
-template <typename value_type> struct pod_serializer {
-  template <typename INPUT>
-  bool operator()(INPUT* fp, value_type* value) const {
-    return read_data(fp, value, sizeof(*value));
-  }
-
-  template <typename OUTPUT>
-  bool operator()(OUTPUT* fp, const value_type& value) const {
-    return write_data(fp, &value, sizeof(value));
-  }
-};
-
-
-// Settings contains parameters for growing and shrinking the table.
-// It also packages zero-size functor (ie. hasher).
-//
-// It does some munging of the hash value in cases where we think
-// (fear) the original hash function might not be very good.  In
-// particular, the default hash of pointers is the identity hash,
-// so probably all the low bits are 0.  We identify when we think
-// we're hashing a pointer, and chop off the low bits.  Note this
-// isn't perfect: even when the key is a pointer, we can't tell
-// for sure that the hash is the identity hash.  If it's not, this
-// is needless work (and possibly, though not likely, harmful).
-
-template<typename Key, typename HashFunc,
-         typename SizeType, int HT_MIN_BUCKETS>
-class sh_hashtable_settings : public HashFunc {
- public:
-  typedef Key key_type;
-  typedef HashFunc hasher;
-  typedef SizeType size_type;
-
- public:
-  sh_hashtable_settings(const hasher& hf,
-                        const float ht_occupancy_flt,
-                        const float ht_empty_flt)
-      : hasher(hf),
-        enlarge_threshold_(0),
-        shrink_threshold_(0),
-        consider_shrink_(false),
-        use_empty_(false),
-        use_deleted_(false),
-        num_ht_copies_(0) {
-    set_enlarge_factor(ht_occupancy_flt);
-    set_shrink_factor(ht_empty_flt);
-  }
-
-  size_type hash(const key_type& v) const {
-    // We munge the hash value when we don't trust hasher::operator().
-    return hash_munger<Key>::MungedHash(hasher::operator()(v));
-  }
-
-  float enlarge_factor() const {
-    return enlarge_factor_;
-  }
-  void set_enlarge_factor(float f) {
-    enlarge_factor_ = f;
-  }
-  float shrink_factor() const {
-    return shrink_factor_;
-  }
-  void set_shrink_factor(float f) {
-    shrink_factor_ = f;
-  }
-
-  size_type enlarge_threshold() const {
-    return enlarge_threshold_;
-  }
-  void set_enlarge_threshold(size_type t) {
-    enlarge_threshold_ = t;
-  }
-  size_type shrink_threshold() const {
-    return shrink_threshold_;
-  }
-  void set_shrink_threshold(size_type t) {
-    shrink_threshold_ = t;
-  }
-
-  size_type enlarge_size(size_type x) const {
-    return static_cast<size_type>(x * enlarge_factor_);
-  }
-  size_type shrink_size(size_type x) const {
-    return static_cast<size_type>(x * shrink_factor_);
-  }
-
-  bool consider_shrink() const {
-    return consider_shrink_;
-  }
-  void set_consider_shrink(bool t) {
-    consider_shrink_ = t;
-  }
-
-  bool use_empty() const {
-    return use_empty_;
-  }
-  void set_use_empty(bool t) {
-    use_empty_ = t;
-  }
-
-  bool use_deleted() const {
-    return use_deleted_;
-  }
-  void set_use_deleted(bool t) {
-    use_deleted_ = t;
-  }
-
-  size_type num_ht_copies() const {
-    return static_cast<size_type>(num_ht_copies_);
-  }
-  void inc_num_ht_copies() {
-    ++num_ht_copies_;
-  }
-
-  // Reset the enlarge and shrink thresholds
-  void reset_thresholds(size_type num_buckets) {
-    set_enlarge_threshold(enlarge_size(num_buckets));
-    set_shrink_threshold(shrink_size(num_buckets));
-    // whatever caused us to reset already considered
-    set_consider_shrink(false);
-  }
-
-  // Caller is resposible for calling reset_threshold right after
-  // set_resizing_parameters.
-  void set_resizing_parameters(float shrink, float grow) {
-    assert(shrink >= 0.0);
-    assert(grow <= 1.0);
-    if (shrink > grow/2.0f)
-      shrink = grow / 2.0f;     // otherwise we thrash hashtable size
-    set_shrink_factor(shrink);
-    set_enlarge_factor(grow);
-  }
-
-  // This is the smallest size a hashtable can be without being too crowded
-  // If you like, you can give a min #buckets as well as a min #elts
-  size_type min_buckets(size_type num_elts, size_type min_buckets_wanted) {
-    float enlarge = enlarge_factor();
-    size_type sz = HT_MIN_BUCKETS;             // min buckets allowed
-    while ( sz < min_buckets_wanted ||
-            num_elts >= static_cast<size_type>(sz * enlarge) ) {
-      // This just prevents overflowing size_type, since sz can exceed
-      // max_size() here.
-      if (static_cast<size_type>(sz * 2) < sz) {
-        throw std::length_error("resize overflow");  // protect against overflow
-      }
-      sz *= 2;
-    }
-    return sz;
-  }
-
- private:
-  template<class HashKey> class hash_munger {
-   public:
-    static size_t MungedHash(size_t hash) {
-      return hash;
-    }
-  };
-  // This matches when the hashtable key is a pointer.
-  template<class HashKey> class hash_munger<HashKey*> {
-   public:
-    static size_t MungedHash(size_t hash) {
-      // TODO(csilvers): consider rotating instead:
-      //    static const int shift = (sizeof(void *) == 4) ? 2 : 3;
-      //    return (hash << (sizeof(hash) * 8) - shift)) | (hash >> shift);
-      // This matters if we ever change sparse/dense_hash_* to compare
-      // hashes before comparing actual values.  It's speedy on x86.
-      return hash / sizeof(void*);   // get rid of known-0 bits
-    }
-  };
-
-  size_type enlarge_threshold_;  // table.size() * enlarge_factor
-  size_type shrink_threshold_;   // table.size() * shrink_factor
-  float enlarge_factor_;         // how full before resize
-  float shrink_factor_;          // how empty before resize
-  // consider_shrink=true if we should try to shrink before next insert
-  bool consider_shrink_;
-  bool use_empty_;    // used only by densehashtable, not sparsehashtable
-  bool use_deleted_;  // false until delkey has been set
-  // num_ht_copies is a counter incremented every Copy/Move
-  unsigned int num_ht_copies_;
-};
-
-}  // namespace sparsehash_internal
-
-#undef SPARSEHASH_COMPILE_ASSERT
-_END_GOOGLE_NAMESPACE_
-
-#endif  // UTIL_GTL_HASHTABLE_COMMON_H_

src/includes/3thparty/sparsehash/internal/libc_allocator_with_realloc.h

@@ -1,122 +0,0 @@
-// Copyright (c) 2010, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-
-#ifndef UTIL_GTL_LIBC_ALLOCATOR_WITH_REALLOC_H_
-#define UTIL_GTL_LIBC_ALLOCATOR_WITH_REALLOC_H_
-
-#include "./sparseconfig.h"
-#include <stdlib.h>           // for malloc/realloc/free
-#include <stddef.h>           // for ptrdiff_t
-#include <new>                // for placement new
-
-_START_GOOGLE_NAMESPACE_
-
-template<class T>
-class libc_allocator_with_realloc {
- public:
-  typedef T value_type;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T& reference;
-  typedef const T& const_reference;
-
-  libc_allocator_with_realloc() {}
-  libc_allocator_with_realloc(const libc_allocator_with_realloc&) {}
-  ~libc_allocator_with_realloc() {}
-
-  pointer address(reference r) const  { return &r; }
-  const_pointer address(const_reference r) const  { return &r; }
-
-  pointer allocate(size_type n, const_pointer = 0) {
-    return static_cast<pointer>(malloc(n * sizeof(value_type)));
-  }
-  void deallocate(pointer p, size_type) {
-    free(p);
-  }
-  pointer reallocate(pointer p, size_type n) {
-    // p points to a storage array whose objects have already been destroyed
-    // cast to void* to prevent compiler warnings about calling realloc() on
-    // an object which cannot be relocated in memory
-    return static_cast<pointer>(realloc(static_cast<void*>(p), n * sizeof(value_type)));
-  }
-
-  size_type max_size() const  {
-    return static_cast<size_type>(-1) / sizeof(value_type);
-  }
-
-  void construct(pointer p, const value_type& val) {
-    new(p) value_type(val);
-  }
-  void destroy(pointer p) { p->~value_type(); }
-
-  template <class U>
-  libc_allocator_with_realloc(const libc_allocator_with_realloc<U>&) {}
-
-  template<class U>
-  struct rebind {
-    typedef libc_allocator_with_realloc<U> other;
-  };
-};
-
-// libc_allocator_with_realloc<void> specialization.
-template<>
-class libc_allocator_with_realloc<void> {
- public:
-  typedef void value_type;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  typedef void* pointer;
-  typedef const void* const_pointer;
-
-  template<class U>
-  struct rebind {
-    typedef libc_allocator_with_realloc<U> other;
-  };
-};
-
-template<class T>
-inline bool operator==(const libc_allocator_with_realloc<T>&,
-                       const libc_allocator_with_realloc<T>&) {
-  return true;
-}
-
-template<class T>
-inline bool operator!=(const libc_allocator_with_realloc<T>&,
-                       const libc_allocator_with_realloc<T>&) {
-  return false;
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif  // UTIL_GTL_LIBC_ALLOCATOR_WITH_REALLOC_H_

src/includes/3thparty/sparsehash/internal/sparseconfig.h

@@ -1,46 +0,0 @@
-/*
- * NOTE: This file is for internal use only.
- *       Do not use these #defines in your own program!
- */
-
-/* Namespace for Google classes */
-#define GOOGLE_NAMESPACE ::google
-
-/* the location of the header defining hash functions */
-#define HASH_FUN_H <functional>
-
-/* the namespace of the hash<> function */
-#define HASH_NAMESPACE std
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if the system has the type `long long'. */
-#define HAVE_LONG_LONG 1
-
-/* Define to 1 if you have the `memcpy' function. */
-#define HAVE_MEMCPY 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if the system has the type `uint16_t'. */
-#define HAVE_UINT16_T 1
-
-/* Define to 1 if the system has the type `u_int16_t'. */
-#define HAVE_U_INT16_T 1
-
-/* Define to 1 if the system has the type `__uint16'. */
-/* #undef HAVE___UINT16 */
-
-/* The system-provided hash function including the namespace. */
-#define SPARSEHASH_HASH HASH_NAMESPACE::hash
-
-/* Stops putting the code inside the Google namespace */
-#define _END_GOOGLE_NAMESPACE_ }
-
-/* Puts following code inside the Google namespace */
-#define _START_GOOGLE_NAMESPACE_ namespace google {

src/includes/3thparty/sparsehash/sparse_hash_map

@@ -1,363 +0,0 @@
-// Copyright (c) 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-//
-// This is just a very thin wrapper over sparsehashtable.h, just
-// like sgi stl's stl_hash_map is a very thin wrapper over
-// stl_hashtable.  The major thing we define is operator[], because
-// we have a concept of a data_type which stl_hashtable doesn't
-// (it only has a key and a value).
-//
-// We adhere mostly to the STL semantics for hash-map.  One important
-// exception is that insert() may invalidate iterators entirely -- STL
-// semantics are that insert() may reorder iterators, but they all
-// still refer to something valid in the hashtable.  Not so for us.
-// Likewise, insert() may invalidate pointers into the hashtable.
-// (Whether insert invalidates iterators and pointers depends on
-// whether it results in a hashtable resize).  On the plus side,
-// delete() doesn't invalidate iterators or pointers at all, or even
-// change the ordering of elements.
-//
-// Here are a few "power user" tips:
-//
-//    1) set_deleted_key():
-//         Unlike STL's hash_map, if you want to use erase() you
-//         *must* call set_deleted_key() after construction.
-//
-//    2) resize(0):
-//         When an item is deleted, its memory isn't freed right
-//         away.  This is what allows you to iterate over a hashtable
-//         and call erase() without invalidating the iterator.
-//         To force the memory to be freed, call resize(0).
-//         For tr1 compatibility, this can also be called as rehash(0).
-//
-//    3) min_load_factor(0.0)
-//         Setting the minimum load factor to 0.0 guarantees that
-//         the hash table will never shrink.
-//
-// Roughly speaking:
-//   (1) dense_hash_map: fastest, uses the most memory unless entries are small
-//   (2) sparse_hash_map: slowest, uses the least memory
-//   (3) hash_map / unordered_map (STL): in the middle
-//
-// Typically I use sparse_hash_map when I care about space and/or when
-// I need to save the hashtable on disk.  I use hash_map otherwise.  I
-// don't personally use dense_hash_map ever; some people use it for
-// small maps with lots of lookups.
-//
-// - dense_hash_map has, typically, about 78% memory overhead (if your
-//   data takes up X bytes, the hash_map uses .78X more bytes in overhead).
-// - sparse_hash_map has about 4 bits overhead per entry.
-// - sparse_hash_map can be 3-7 times slower than the others for lookup and,
-//   especially, inserts.  See time_hash_map.cc for details.
-//
-// See /usr/(local/)?doc/sparsehash-*/sparse_hash_map.html
-// for information about how to use this class.
-
-#ifndef _SPARSE_HASH_MAP_H_
-#define _SPARSE_HASH_MAP_H_
-
-#include "./internal/sparseconfig.h"
-#include <algorithm>                        // needed by stl_alloc
-#include <functional>                       // for equal_to<>, select1st<>, etc
-#include <memory>                           // for alloc
-#include <utility>                          // for pair<>
-#include "./internal/libc_allocator_with_realloc.h"
-#include "./internal/sparsehashtable.h"       // IWYU pragma: export
-#include HASH_FUN_H                 // for hash<>
-_START_GOOGLE_NAMESPACE_
-
-template <class Key, class T,
-          class HashFcn = SPARSEHASH_HASH<Key>,   // defined in sparseconfig.h
-          class EqualKey = std::equal_to<Key>,
-          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T> > >
-class sparse_hash_map {
- private:
-  // Apparently select1st is not stl-standard, so we define our own
-  struct SelectKey {
-    typedef const Key& result_type;
-    const Key& operator()(const std::pair<const Key, T>& p) const {
-      return p.first;
-    }
-  };
-  struct SetKey {
-    void operator()(std::pair<const Key, T>* value, const Key& new_key) const {
-      *const_cast<Key*>(&value->first) = new_key;
-      // It would be nice to clear the rest of value here as well, in
-      // case it's taking up a lot of memory.  We do this by clearing
-      // the value.  This assumes T has a zero-arg constructor!
-      value->second = T();
-    }
-  };
-  // For operator[].
-  struct DefaultValue {
-    std::pair<const Key, T> operator()(const Key& key) {
-      return std::make_pair(key, T());
-    }
-  };
-
-  // The actual data
-  typedef sparse_hashtable<std::pair<const Key, T>, Key, HashFcn, SelectKey,
-                           SetKey, EqualKey, Alloc> ht;
-  ht rep;
-
- public:
-  typedef typename ht::key_type key_type;
-  typedef T data_type;
-  typedef T mapped_type;
-  typedef typename ht::value_type value_type;
-  typedef typename ht::hasher hasher;
-  typedef typename ht::key_equal key_equal;
-  typedef Alloc allocator_type;
-
-  typedef typename ht::size_type size_type;
-  typedef typename ht::difference_type difference_type;
-  typedef typename ht::pointer pointer;
-  typedef typename ht::const_pointer const_pointer;
-  typedef typename ht::reference reference;
-  typedef typename ht::const_reference const_reference;
-
-  typedef typename ht::iterator iterator;
-  typedef typename ht::const_iterator const_iterator;
-  typedef typename ht::local_iterator local_iterator;
-  typedef typename ht::const_local_iterator const_local_iterator;
-
-  // Iterator functions
-  iterator begin()                               { return rep.begin(); }
-  iterator end()                                 { return rep.end(); }
-  const_iterator begin() const                   { return rep.begin(); }
-  const_iterator end() const                     { return rep.end(); }
-
-  // These come from tr1's unordered_map. For us, a bucket has 0 or 1 elements.
-  local_iterator begin(size_type i)              { return rep.begin(i); }
-  local_iterator end(size_type i)                { return rep.end(i); }
-  const_local_iterator begin(size_type i) const  { return rep.begin(i); }
-  const_local_iterator end(size_type i) const    { return rep.end(i); }
-
-  // Accessor functions
-  allocator_type get_allocator() const           { return rep.get_allocator(); }
-  hasher hash_funct() const                      { return rep.hash_funct(); }
-  hasher hash_function() const                   { return hash_funct(); }
-  key_equal key_eq() const                       { return rep.key_eq(); }
-
-
-  // Constructors
-  explicit sparse_hash_map(size_type expected_max_items_in_table = 0,
-                           const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal(),
-                           const allocator_type& alloc = allocator_type())
-    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
-  }
-
-  template <class InputIterator>
-  sparse_hash_map(InputIterator f, InputIterator l,
-                  size_type expected_max_items_in_table = 0,
-                  const hasher& hf = hasher(),
-                  const key_equal& eql = key_equal(),
-                  const allocator_type& alloc = allocator_type())
-    : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(), alloc) {
-    rep.insert(f, l);
-  }
-  // We use the default copy constructor
-  // We use the default operator=()
-  // We use the default destructor
-
-  void clear()                        { rep.clear(); }
-  void swap(sparse_hash_map& hs)      { rep.swap(hs.rep); }
-
-
-  // Functions concerning size
-  size_type size() const              { return rep.size(); }
-  size_type max_size() const          { return rep.max_size(); }
-  bool empty() const                  { return rep.empty(); }
-  size_type bucket_count() const      { return rep.bucket_count(); }
-  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
-
-  // These are tr1 methods.  bucket() is the bucket the key is or would be in.
-  size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
-  size_type bucket(const key_type& key) const { return rep.bucket(key); }
-  float load_factor() const {
-    return size() * 1.0f / bucket_count();
-  }
-  float max_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return grow;
-  }
-  void max_load_factor(float new_grow) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(shrink, new_grow);
-  }
-  // These aren't tr1 methods but perhaps ought to be.
-  float min_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return shrink;
-  }
-  void min_load_factor(float new_shrink) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(new_shrink, grow);
-  }
-  // Deprecated; use min_load_factor() or max_load_factor() instead.
-  void set_resizing_parameters(float shrink, float grow) {
-    rep.set_resizing_parameters(shrink, grow);
-  }
-
-  void resize(size_type hint)         { rep.resize(hint); }
-  void rehash(size_type hint)         { resize(hint); }      // the tr1 name
-
-  // Lookup routines
-  iterator find(const key_type& key)                 { return rep.find(key); }
-  const_iterator find(const key_type& key) const     { return rep.find(key); }
-
-  data_type& operator[](const key_type& key) {       // This is our value-add!
-    // If key is in the hashtable, returns find(key)->second,
-    // otherwise returns insert(value_type(key, T()).first->second.
-    // Note it does not create an empty T unless the find fails.
-    return rep.template find_or_insert<DefaultValue>(key).second;
-  }
-
-  size_type count(const key_type& key) const         { return rep.count(key); }
-
-  std::pair<iterator, iterator> equal_range(const key_type& key) {
-    return rep.equal_range(key);
-  }
-  std::pair<const_iterator, const_iterator> equal_range(const key_type& key)
-      const {
-    return rep.equal_range(key);
-  }
-
-  // Insertion routines
-  std::pair<iterator, bool> insert(const value_type& obj) {
-    return rep.insert(obj);
-  }
-  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
-    rep.insert(f, l);
-  }
-  void insert(const_iterator f, const_iterator l) {
-    rep.insert(f, l);
-  }
-  // Required for std::insert_iterator; the passed-in iterator is ignored.
-  iterator insert(iterator, const value_type& obj) {
-    return insert(obj).first;
-  }
-
-  // Deletion routines
-  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
-  // value to identify deleted buckets.  You can change the key as
-  // time goes on, or get rid of it entirely to be insert-only.
-  void set_deleted_key(const key_type& key)   {
-    rep.set_deleted_key(key);
-  }
-  void clear_deleted_key()                    { rep.clear_deleted_key(); }
-  key_type deleted_key() const                { return rep.deleted_key(); }
-
-  // These are standard
-  size_type erase(const key_type& key)               { return rep.erase(key); }
-  void erase(iterator it)                            { rep.erase(it); }
-  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
-
-
-  // Comparison
-  bool operator==(const sparse_hash_map& hs) const   { return rep == hs.rep; }
-  bool operator!=(const sparse_hash_map& hs) const   { return rep != hs.rep; }
-
-
-  // I/O -- this is an add-on for writing metainformation to disk
-  //
-  // For maximum flexibility, this does not assume a particular
-  // file type (though it will probably be a FILE *).  We just pass
-  // the fp through to rep.
-
-  // If your keys and values are simple enough, you can pass this
-  // serializer to serialize()/unserialize().  "Simple enough" means
-  // value_type is a POD type that contains no pointers.  Note,
-  // however, we don't try to normalize endianness.
-  typedef typename ht::NopointerSerializer NopointerSerializer;
-
-  // serializer: a class providing operator()(OUTPUT*, const value_type&)
-  //    (writing value_type to OUTPUT).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
-  //    pointer to a class providing size_t Write(const void*, size_t),
-  //    which writes a buffer into a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully written.
-  //    Note basic_ostream<not_char> is not currently supported.
-  template <typename ValueSerializer, typename OUTPUT>
-  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
-    return rep.serialize(serializer, fp);
-  }
-
-  // serializer: a functor providing operator()(INPUT*, value_type*)
-  //    (reading from INPUT and into value_type).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
-  //    pointer to a class providing size_t Read(void*, size_t),
-  //    which reads into a buffer from a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully read.
-  //    Note basic_istream<not_char> is not currently supported.
-  // NOTE: Since value_type is std::pair<const Key, T>, ValueSerializer
-  // may need to do a const cast in order to fill in the key.
-  // NOTE: if Key or T are not POD types, the serializer MUST use
-  // placement-new to initialize their values, rather than a normal
-  // equals-assignment or similar.  (The value_type* passed into the
-  // serializer points to garbage memory.)
-  template <typename ValueSerializer, typename INPUT>
-  bool unserialize(ValueSerializer serializer, INPUT* fp) {
-    return rep.unserialize(serializer, fp);
-  }
-
-  // The four methods below are DEPRECATED.
-  // Use serialize() and unserialize() for new code.
-  template <typename OUTPUT>
-  bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
-
-  template <typename INPUT>
-  bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
-
-  template <typename OUTPUT>
-  bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
-
-  template <typename INPUT>
-  bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
-};
-
-// We need a global swap as well
-template <class Key, class T, class HashFcn, class EqualKey, class Alloc>
-inline void swap(sparse_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,
-                 sparse_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2) {
-  hm1.swap(hm2);
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif /* _SPARSE_HASH_MAP_H_ */

src/includes/3thparty/sparsehash/sparse_hash_set

@@ -1,338 +0,0 @@
-// Copyright (c) 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-//
-// This is just a very thin wrapper over sparsehashtable.h, just
-// like sgi stl's stl_hash_set is a very thin wrapper over
-// stl_hashtable.  The major thing we define is operator[], because
-// we have a concept of a data_type which stl_hashtable doesn't
-// (it only has a key and a value).
-//
-// This is more different from sparse_hash_map than you might think,
-// because all iterators for sets are const (you obviously can't
-// change the key, and for sets there is no value).
-//
-// We adhere mostly to the STL semantics for hash-map.  One important
-// exception is that insert() may invalidate iterators entirely -- STL
-// semantics are that insert() may reorder iterators, but they all
-// still refer to something valid in the hashtable.  Not so for us.
-// Likewise, insert() may invalidate pointers into the hashtable.
-// (Whether insert invalidates iterators and pointers depends on
-// whether it results in a hashtable resize).  On the plus side,
-// delete() doesn't invalidate iterators or pointers at all, or even
-// change the ordering of elements.
-//
-// Here are a few "power user" tips:
-//
-//    1) set_deleted_key():
-//         Unlike STL's hash_map, if you want to use erase() you
-//         *must* call set_deleted_key() after construction.
-//
-//    2) resize(0):
-//         When an item is deleted, its memory isn't freed right
-//         away.  This allows you to iterate over a hashtable,
-//         and call erase(), without invalidating the iterator.
-//         To force the memory to be freed, call resize(0).
-//         For tr1 compatibility, this can also be called as rehash(0).
-//
-//    3) min_load_factor(0.0)
-//         Setting the minimum load factor to 0.0 guarantees that
-//         the hash table will never shrink.
-//
-// Roughly speaking:
-//   (1) dense_hash_set: fastest, uses the most memory unless entries are small
-//   (2) sparse_hash_set: slowest, uses the least memory
-//   (3) hash_set / unordered_set (STL): in the middle
-//
-// Typically I use sparse_hash_set when I care about space and/or when
-// I need to save the hashtable on disk.  I use hash_set otherwise.  I
-// don't personally use dense_hash_set ever; some people use it for
-// small sets with lots of lookups.
-//
-// - dense_hash_set has, typically, about 78% memory overhead (if your
-//   data takes up X bytes, the hash_set uses .78X more bytes in overhead).
-// - sparse_hash_set has about 4 bits overhead per entry.
-// - sparse_hash_set can be 3-7 times slower than the others for lookup and,
-//   especially, inserts.  See time_hash_map.cc for details.
-//
-// See /usr/(local/)?doc/sparsehash-*/sparse_hash_set.html
-// for information about how to use this class.
-
-#ifndef _SPARSE_HASH_SET_H_
-#define _SPARSE_HASH_SET_H_
-
-#include <sparsehash/internal/sparseconfig.h>
-#include <algorithm>                       // needed by stl_alloc
-#include <functional>                      // for equal_to<>
-#include <memory>                          // for alloc (which we don't use)
-#include <utility>                         // for pair<>
-#include <sparsehash/internal/libc_allocator_with_realloc.h>
-#include <sparsehash/internal/sparsehashtable.h>      // IWYU pragma: export
-#include HASH_FUN_H                // for hash<>
-
-_START_GOOGLE_NAMESPACE_
-
-template <class Value,
-          class HashFcn = SPARSEHASH_HASH<Value>,   // defined in sparseconfig.h
-          class EqualKey = std::equal_to<Value>,
-          class Alloc = libc_allocator_with_realloc<Value> >
-class sparse_hash_set {
- private:
-  // Apparently identity is not stl-standard, so we define our own
-  struct Identity {
-    typedef const Value& result_type;
-    const Value& operator()(const Value& v) const { return v; }
-  };
-  struct SetKey {
-    void operator()(Value* value, const Value& new_key) const {
-      *value = new_key;
-    }
-  };
-
-  typedef sparse_hashtable<Value, Value, HashFcn, Identity, SetKey,
-                           EqualKey, Alloc> ht;
-  ht rep;
-
- public:
-  typedef typename ht::key_type key_type;
-  typedef typename ht::value_type value_type;
-  typedef typename ht::hasher hasher;
-  typedef typename ht::key_equal key_equal;
-  typedef Alloc allocator_type;
-
-  typedef typename ht::size_type size_type;
-  typedef typename ht::difference_type difference_type;
-  typedef typename ht::const_pointer pointer;
-  typedef typename ht::const_pointer const_pointer;
-  typedef typename ht::const_reference reference;
-  typedef typename ht::const_reference const_reference;
-
-  typedef typename ht::const_iterator iterator;
-  typedef typename ht::const_iterator const_iterator;
-  typedef typename ht::const_local_iterator local_iterator;
-  typedef typename ht::const_local_iterator const_local_iterator;
-
-
-  // Iterator functions -- recall all iterators are const
-  iterator begin() const                  { return rep.begin(); }
-  iterator end() const                    { return rep.end(); }
-
-  // These come from tr1's unordered_set. For us, a bucket has 0 or 1 elements.
-  local_iterator begin(size_type i) const { return rep.begin(i); }
-  local_iterator end(size_type i) const   { return rep.end(i); }
-
-
-  // Accessor functions
-  allocator_type get_allocator() const    { return rep.get_allocator(); }
-  hasher hash_funct() const               { return rep.hash_funct(); }
-  hasher hash_function() const            { return hash_funct(); }  // tr1 name
-  key_equal key_eq() const                { return rep.key_eq(); }
-
-
-  // Constructors
-  explicit sparse_hash_set(size_type expected_max_items_in_table = 0,
-                           const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal(),
-                           const allocator_type& alloc = allocator_type())
-      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
-  }
-
-  template <class InputIterator>
-  sparse_hash_set(InputIterator f, InputIterator l,
-                  size_type expected_max_items_in_table = 0,
-                  const hasher& hf = hasher(),
-                  const key_equal& eql = key_equal(),
-                  const allocator_type& alloc = allocator_type())
-      : rep(expected_max_items_in_table, hf, eql, Identity(), SetKey(), alloc) {
-    rep.insert(f, l);
-  }
-  // We use the default copy constructor
-  // We use the default operator=()
-  // We use the default destructor
-
-  void clear()                        { rep.clear(); }
-  void swap(sparse_hash_set& hs)      { rep.swap(hs.rep); }
-
-
-  // Functions concerning size
-  size_type size() const              { return rep.size(); }
-  size_type max_size() const          { return rep.max_size(); }
-  bool empty() const                  { return rep.empty(); }
-  size_type bucket_count() const      { return rep.bucket_count(); }
-  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
-
-  // These are tr1 methods.  bucket() is the bucket the key is or would be in.
-  size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
-  size_type bucket(const key_type& key) const { return rep.bucket(key); }
-  float load_factor() const {
-    return size() * 1.0f / bucket_count();
-  }
-  float max_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return grow;
-  }
-  void max_load_factor(float new_grow) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(shrink, new_grow);
-  }
-  // These aren't tr1 methods but perhaps ought to be.
-  float min_load_factor() const {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    return shrink;
-  }
-  void min_load_factor(float new_shrink) {
-    float shrink, grow;
-    rep.get_resizing_parameters(&shrink, &grow);
-    rep.set_resizing_parameters(new_shrink, grow);
-  }
-  // Deprecated; use min_load_factor() or max_load_factor() instead.
-  void set_resizing_parameters(float shrink, float grow) {
-    rep.set_resizing_parameters(shrink, grow);
-  }
-
-  void resize(size_type hint)         { rep.resize(hint); }
-  void rehash(size_type hint)         { resize(hint); }     // the tr1 name
-
-  // Lookup routines
-  iterator find(const key_type& key) const           { return rep.find(key); }
-
-  size_type count(const key_type& key) const         { return rep.count(key); }
-
-  std::pair<iterator, iterator> equal_range(const key_type& key) const {
-    return rep.equal_range(key);
-  }
-
-
-  // Insertion routines
-  std::pair<iterator, bool> insert(const value_type& obj) {
-    std::pair<typename ht::iterator, bool> p = rep.insert(obj);
-    return std::pair<iterator, bool>(p.first, p.second);   // const to non-const
-  }
-  template <class InputIterator> void insert(InputIterator f, InputIterator l) {
-    rep.insert(f, l);
-  }
-  void insert(const_iterator f, const_iterator l) {
-    rep.insert(f, l);
-  }
-  // Required for std::insert_iterator; the passed-in iterator is ignored.
-  iterator insert(iterator, const value_type& obj)   {
-    return insert(obj).first;
-  }
-
-  // Deletion routines
-  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
-  // value to identify deleted buckets.  You can change the key as
-  // time goes on, or get rid of it entirely to be insert-only.
-  void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
-  void clear_deleted_key()                    { rep.clear_deleted_key(); }
-  key_type deleted_key() const                { return rep.deleted_key(); }
-
-  // These are standard
-  size_type erase(const key_type& key)               { return rep.erase(key); }
-  void erase(iterator it)                            { rep.erase(it); }
-  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
-
-
-  // Comparison
-  bool operator==(const sparse_hash_set& hs) const   { return rep == hs.rep; }
-  bool operator!=(const sparse_hash_set& hs) const   { return rep != hs.rep; }
-
-
-  // I/O -- this is an add-on for writing metainformation to disk
-  //
-  // For maximum flexibility, this does not assume a particular
-  // file type (though it will probably be a FILE *).  We just pass
-  // the fp through to rep.
-
-  // If your keys and values are simple enough, you can pass this
-  // serializer to serialize()/unserialize().  "Simple enough" means
-  // value_type is a POD type that contains no pointers.  Note,
-  // however, we don't try to normalize endianness.
-  typedef typename ht::NopointerSerializer NopointerSerializer;
-
-  // serializer: a class providing operator()(OUTPUT*, const value_type&)
-  //    (writing value_type to OUTPUT).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
-  //    pointer to a class providing size_t Write(const void*, size_t),
-  //    which writes a buffer into a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully written.
-  //    Note basic_ostream<not_char> is not currently supported.
-  template <typename ValueSerializer, typename OUTPUT>
-  bool serialize(ValueSerializer serializer, OUTPUT* fp) {
-    return rep.serialize(serializer, fp);
-  }
-
-  // serializer: a functor providing operator()(INPUT*, value_type*)
-  //    (reading from INPUT and into value_type).  You can specify a
-  //    NopointerSerializer object if appropriate (see above).
-  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
-  //    pointer to a class providing size_t Read(void*, size_t),
-  //    which reads into a buffer from a stream (which fp presumably
-  //    owns) and returns the number of bytes successfully read.
-  //    Note basic_istream<not_char> is not currently supported.
-  // NOTE: Since value_type is const Key, ValueSerializer
-  // may need to do a const cast in order to fill in the key.
-  // NOTE: if Key is not a POD type, the serializer MUST use
-  // placement-new to initialize its value, rather than a normal
-  // equals-assignment or similar.  (The value_type* passed into
-  // the serializer points to garbage memory.)
-  template <typename ValueSerializer, typename INPUT>
-  bool unserialize(ValueSerializer serializer, INPUT* fp) {
-    return rep.unserialize(serializer, fp);
-  }
-
-  // The four methods below are DEPRECATED.
-  // Use serialize() and unserialize() for new code.
-  template <typename OUTPUT>
-  bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
-
-  template <typename INPUT>
-  bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
-
-  template <typename OUTPUT>
-  bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
-
-  template <typename INPUT>
-  bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
-};
-
-template <class Val, class HashFcn, class EqualKey, class Alloc>
-inline void swap(sparse_hash_set<Val, HashFcn, EqualKey, Alloc>& hs1,
-                 sparse_hash_set<Val, HashFcn, EqualKey, Alloc>& hs2) {
-  hs1.swap(hs2);
-}
-
-_END_GOOGLE_NAMESPACE_
-
-#endif /* _SPARSE_HASH_SET_H_ */

src/includes/3thparty/sparsehash/template_util.h

@@ -1,134 +0,0 @@
-// Copyright 2005 Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ----
-//
-// Template metaprogramming utility functions.
-//
-// This code is compiled directly on many platforms, including client
-// platforms like Windows, Mac, and embedded systems.  Before making
-// any changes here, make sure that you're not breaking any platforms.
-//
-//
-// The names choosen here reflect those used in tr1 and the boost::mpl
-// library, there are similar operations used in the Loki library as
-// well.  I prefer the boost names for 2 reasons:
-// 1.  I think that portions of the Boost libraries are more likely to
-// be included in the c++ standard.
-// 2.  It is not impossible that some of the boost libraries will be
-// included in our own build in the future.
-// Both of these outcomes means that we may be able to directly replace
-// some of these with boost equivalents.
-//
-#ifndef BASE_TEMPLATE_UTIL_H_
-#define BASE_TEMPLATE_UTIL_H_
-
-#include "./internal/sparseconfig.h"
-_START_GOOGLE_NAMESPACE_
-
-// Types small_ and big_ are guaranteed such that sizeof(small_) <
-// sizeof(big_)
-typedef char small_;
-
-struct big_ {
-  char dummy[2];
-};
-
-// Identity metafunction.
-template <class T>
-struct identity_ {
-  typedef T type;
-};
-
-// integral_constant, defined in tr1, is a wrapper for an integer
-// value. We don't really need this generality; we could get away
-// with hardcoding the integer type to bool. We use the fully
-// general integer_constant for compatibility with tr1.
-
-template<class T, T v>
-struct integral_constant {
-  static const T value = v;
-  typedef T value_type;
-  typedef integral_constant<T, v> type;
-};
-
-template <class T, T v> const T integral_constant<T, v>::value;
-
-
-// Abbreviations: true_type and false_type are structs that represent boolean
-// true and false values. Also define the boost::mpl versions of those names,
-// true_ and false_.
-typedef integral_constant<bool, true>  true_type;
-typedef integral_constant<bool, false> false_type;
-typedef true_type  true_;
-typedef false_type false_;
-
-// if_ is a templatized conditional statement.
-// if_<cond, A, B> is a compile time evaluation of cond.
-// if_<>::type contains A if cond is true, B otherwise.
-template<bool cond, typename A, typename B>
-struct if_{
-  typedef A type;
-};
-
-template<typename A, typename B>
-struct if_<false, A, B> {
-  typedef B type;
-};
-
-
-// type_equals_ is a template type comparator, similar to Loki IsSameType.
-// type_equals_<A, B>::value is true iff "A" is the same type as "B".
-//
-// New code should prefer base::is_same, defined in base/type_traits.h.
-// It is functionally identical, but is_same is the standard spelling.
-template<typename A, typename B>
-struct type_equals_ : public false_ {
-};
-
-template<typename A>
-struct type_equals_<A, A> : public true_ {
-};
-
-// and_ is a template && operator.
-// and_<A, B>::value evaluates "A::value && B::value".
-template<typename A, typename B>
-struct and_ : public integral_constant<bool, (A::value && B::value)> {
-};
-
-// or_ is a template || operator.
-// or_<A, B>::value evaluates "A::value || B::value".
-template<typename A, typename B>
-struct or_ : public integral_constant<bool, (A::value || B::value)> {
-};
-
-
-_END_GOOGLE_NAMESPACE_
-
-#endif  // BASE_TEMPLATE_UTIL_H_

src/includes/3thparty/sparsehash/type_traits.h

@@ -1,342 +0,0 @@
-// Copyright (c) 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ----
-//
-// This code is compiled directly on many platforms, including client
-// platforms like Windows, Mac, and embedded systems.  Before making
-// any changes here, make sure that you're not breaking any platforms.
-//
-// Define a small subset of tr1 type traits. The traits we define are:
-//   is_integral
-//   is_floating_point
-//   is_pointer
-//   is_enum
-//   is_reference
-//   is_pod
-//   has_trivial_constructor
-//   has_trivial_copy
-//   has_trivial_assign
-//   has_trivial_destructor
-//   remove_const
-//   remove_volatile
-//   remove_cv
-//   remove_reference
-//   add_reference
-//   remove_pointer
-//   is_same
-//   is_convertible
-// We can add more type traits as required.
-
-#ifndef BASE_TYPE_TRAITS_H_
-#define BASE_TYPE_TRAITS_H_
-
-#include "./internal/sparseconfig.h"
-#include <utility>                  // For pair
-
-#include "./template_util.h"    // For true_type and false_type
-
-_START_GOOGLE_NAMESPACE_
-
-template <class T> struct is_integral;
-template <class T> struct is_floating_point;
-template <class T> struct is_pointer;
-// MSVC can't compile this correctly, and neither can gcc 3.3.5 (at least)
-#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
-// is_enum uses is_convertible, which is not available on MSVC.
-template <class T> struct is_enum;
-#endif
-template <class T> struct is_reference;
-template <class T> struct is_pod;
-template <class T> struct has_trivial_constructor;
-template <class T> struct has_trivial_copy;
-template <class T> struct has_trivial_assign;
-template <class T> struct has_trivial_destructor;
-template <class T> struct remove_const;
-template <class T> struct remove_volatile;
-template <class T> struct remove_cv;
-template <class T> struct remove_reference;
-template <class T> struct add_reference;
-template <class T> struct remove_pointer;
-template <class T, class U> struct is_same;
-#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
-template <class From, class To> struct is_convertible;
-#endif
-
-// is_integral is false except for the built-in integer types. A
-// cv-qualified type is integral if and only if the underlying type is.
-template <class T> struct is_integral : false_type { };
-template<> struct is_integral<bool> : true_type { };
-template<> struct is_integral<char> : true_type { };
-template<> struct is_integral<unsigned char> : true_type { };
-template<> struct is_integral<signed char> : true_type { };
-#if defined(_MSC_VER)
-// wchar_t is not by default a distinct type from unsigned short in
-// Microsoft C.
-// See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx
-template<> struct is_integral<__wchar_t> : true_type { };
-#else
-template<> struct is_integral<wchar_t> : true_type { };
-#endif
-template<> struct is_integral<short> : true_type { };
-template<> struct is_integral<unsigned short> : true_type { };
-template<> struct is_integral<int> : true_type { };
-template<> struct is_integral<unsigned int> : true_type { };
-template<> struct is_integral<long> : true_type { };
-template<> struct is_integral<unsigned long> : true_type { };
-#ifdef HAVE_LONG_LONG
-template<> struct is_integral<long long> : true_type { };
-template<> struct is_integral<unsigned long long> : true_type { };
-#endif
-template <class T> struct is_integral<const T> : is_integral<T> { };
-template <class T> struct is_integral<volatile T> : is_integral<T> { };
-template <class T> struct is_integral<const volatile T> : is_integral<T> { };
-
-// is_floating_point is false except for the built-in floating-point types.
-// A cv-qualified type is integral if and only if the underlying type is.
-template <class T> struct is_floating_point : false_type { };
-template<> struct is_floating_point<float> : true_type { };
-template<> struct is_floating_point<double> : true_type { };
-template<> struct is_floating_point<long double> : true_type { };
-template <class T> struct is_floating_point<const T>
-    : is_floating_point<T> { };
-template <class T> struct is_floating_point<volatile T>
-    : is_floating_point<T> { };
-template <class T> struct is_floating_point<const volatile T>
-    : is_floating_point<T> { };
-
-// is_pointer is false except for pointer types. A cv-qualified type (e.g.
-// "int* const", as opposed to "int const*") is cv-qualified if and only if
-// the underlying type is.
-template <class T> struct is_pointer : false_type { };
-template <class T> struct is_pointer<T*> : true_type { };
-template <class T> struct is_pointer<const T> : is_pointer<T> { };
-template <class T> struct is_pointer<volatile T> : is_pointer<T> { };
-template <class T> struct is_pointer<const volatile T> : is_pointer<T> { };
-
-#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
-
-namespace internal {
-
-template <class T> struct is_class_or_union {
-  template <class U> static small_ tester(void (U::*)());
-  template <class U> static big_ tester(...);
-  static const bool value = sizeof(tester<T>(0)) == sizeof(small_);
-};
-
-// is_convertible chokes if the first argument is an array. That's why
-// we use add_reference here.
-template <bool NotUnum, class T> struct is_enum_impl
-    : is_convertible<typename add_reference<T>::type, int> { };
-
-template <class T> struct is_enum_impl<true, T> : false_type { };
-
-}  // namespace internal
-
-// Specified by TR1 [4.5.1] primary type categories.
-
-// Implementation note:
-//
-// Each type is either void, integral, floating point, array, pointer,
-// reference, member object pointer, member function pointer, enum,
-// union or class. Out of these, only integral, floating point, reference,
-// class and enum types are potentially convertible to int. Therefore,
-// if a type is not a reference, integral, floating point or class and
-// is convertible to int, it's a enum. Adding cv-qualification to a type
-// does not change whether it's an enum.
-//
-// Is-convertible-to-int check is done only if all other checks pass,
-// because it can't be used with some types (e.g. void or classes with
-// inaccessible conversion operators).
-template <class T> struct is_enum
-    : internal::is_enum_impl<
-          is_same<T, void>::value ||
-              is_integral<T>::value ||
-              is_floating_point<T>::value ||
-              is_reference<T>::value ||
-              internal::is_class_or_union<T>::value,
-          T> { };
-
-template <class T> struct is_enum<const T> : is_enum<T> { };
-template <class T> struct is_enum<volatile T> : is_enum<T> { };
-template <class T> struct is_enum<const volatile T> : is_enum<T> { };
-
-#endif
-
-// is_reference is false except for reference types.
-template<typename T> struct is_reference : false_type {};
-template<typename T> struct is_reference<T&> : true_type {};
-
-
-// We can't get is_pod right without compiler help, so fail conservatively.
-// We will assume it's false except for arithmetic types, enumerations,
-// pointers and cv-qualified versions thereof. Note that std::pair<T,U>
-// is not a POD even if T and U are PODs.
-template <class T> struct is_pod
- : integral_constant<bool, (is_integral<T>::value ||
-                            is_floating_point<T>::value ||
-#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
-                            // is_enum is not available on MSVC.
-                            is_enum<T>::value ||
-#endif
-                            is_pointer<T>::value)> { };
-template <class T> struct is_pod<const T> : is_pod<T> { };
-template <class T> struct is_pod<volatile T> : is_pod<T> { };
-template <class T> struct is_pod<const volatile T> : is_pod<T> { };
-
-
-// We can't get has_trivial_constructor right without compiler help, so
-// fail conservatively. We will assume it's false except for: (1) types
-// for which is_pod is true. (2) std::pair of types with trivial
-// constructors. (3) array of a type with a trivial constructor.
-// (4) const versions thereof.
-template <class T> struct has_trivial_constructor : is_pod<T> { };
-template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
-  : integral_constant<bool,
-                      (has_trivial_constructor<T>::value &&
-                       has_trivial_constructor<U>::value)> { };
-template <class A, int N> struct has_trivial_constructor<A[N]>
-  : has_trivial_constructor<A> { };
-template <class T> struct has_trivial_constructor<const T>
-  : has_trivial_constructor<T> { };
-
-// We can't get has_trivial_copy right without compiler help, so fail
-// conservatively. We will assume it's false except for: (1) types
-// for which is_pod is true. (2) std::pair of types with trivial copy
-// constructors. (3) array of a type with a trivial copy constructor.
-// (4) const versions thereof.
-template <class T> struct has_trivial_copy : is_pod<T> { };
-template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
-  : integral_constant<bool,
-                      (has_trivial_copy<T>::value &&
-                       has_trivial_copy<U>::value)> { };
-template <class A, int N> struct has_trivial_copy<A[N]>
-  : has_trivial_copy<A> { };
-template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
-
-// We can't get has_trivial_assign right without compiler help, so fail
-// conservatively. We will assume it's false except for: (1) types
-// for which is_pod is true. (2) std::pair of types with trivial copy
-// constructors. (3) array of a type with a trivial assign constructor.
-template <class T> struct has_trivial_assign : is_pod<T> { };
-template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
-  : integral_constant<bool,
-                      (has_trivial_assign<T>::value &&
-                       has_trivial_assign<U>::value)> { };
-template <class A, int N> struct has_trivial_assign<A[N]>
-  : has_trivial_assign<A> { };
-
-// We can't get has_trivial_destructor right without compiler help, so
-// fail conservatively. We will assume it's false except for: (1) types
-// for which is_pod is true. (2) std::pair of types with trivial
-// destructors. (3) array of a type with a trivial destructor.
-// (4) const versions thereof.
-template <class T> struct has_trivial_destructor : is_pod<T> { };
-template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
-  : integral_constant<bool,
-                      (has_trivial_destructor<T>::value &&
-                       has_trivial_destructor<U>::value)> { };
-template <class A, int N> struct has_trivial_destructor<A[N]>
-  : has_trivial_destructor<A> { };
-template <class T> struct has_trivial_destructor<const T>
-  : has_trivial_destructor<T> { };
-
-// Specified by TR1 [4.7.1]
-template<typename T> struct remove_const { typedef T type; };
-template<typename T> struct remove_const<T const> { typedef T type; };
-template<typename T> struct remove_volatile { typedef T type; };
-template<typename T> struct remove_volatile<T volatile> { typedef T type; };
-template<typename T> struct remove_cv {
-  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
-};
-
-
-// Specified by TR1 [4.7.2] Reference modifications.
-template<typename T> struct remove_reference { typedef T type; };
-template<typename T> struct remove_reference<T&> { typedef T type; };
-
-template <typename T> struct add_reference { typedef T& type; };
-template <typename T> struct add_reference<T&> { typedef T& type; };
-
-// Specified by TR1 [4.7.4] Pointer modifications.
-template<typename T> struct remove_pointer { typedef T type; };
-template<typename T> struct remove_pointer<T*> { typedef T type; };
-template<typename T> struct remove_pointer<T* const> { typedef T type; };
-template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
-template<typename T> struct remove_pointer<T* const volatile> {
-  typedef T type; };
-
-// Specified by TR1 [4.6] Relationships between types
-template<typename T, typename U> struct is_same : public false_type { };
-template<typename T> struct is_same<T, T> : public true_type { };
-
-// Specified by TR1 [4.6] Relationships between types
-#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
-namespace internal {
-
-// This class is an implementation detail for is_convertible, and you
-// don't need to know how it works to use is_convertible. For those
-// who care: we declare two different functions, one whose argument is
-// of type To and one with a variadic argument list. We give them
-// return types of different size, so we can use sizeof to trick the
-// compiler into telling us which function it would have chosen if we
-// had called it with an argument of type From.  See Alexandrescu's
-// _Modern C++ Design_ for more details on this sort of trick.
-
-template <typename From, typename To>
-struct ConvertHelper {
-  static small_ Test(To);
-  static big_ Test(...);
-  static From Create();
-};
-}  // namespace internal
-
-// Inherits from true_type if From is convertible to To, false_type otherwise.
-template <typename From, typename To>
-struct is_convertible
-    : integral_constant<bool,
-                        sizeof(internal::ConvertHelper<From, To>::Test(
-                                  internal::ConvertHelper<From, To>::Create()))
-                        == sizeof(small_)> {
-};
-#endif
-
-_END_GOOGLE_NAMESPACE_
-
-// Right now these macros are no-ops, and mostly just document the fact
-// these types are PODs, for human use.  They may be made more contentful
-// later.  The typedef is just to make it legal to put a semicolon after
-// these macros.
-#define DECLARE_POD(TypeName) typedef int Dummy_Type_For_DECLARE_POD
-#define DECLARE_NESTED_POD(TypeName) DECLARE_POD(TypeName)
-#define PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT(TemplateName)             \
-    typedef int Dummy_Type_For_PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT
-#define ENFORCE_POD(TypeName) typedef int Dummy_Type_For_ENFORCE_POD
-
-#endif  // BASE_TYPE_TRAITS_H_

src/includes/3thparty/tsl/CMakeFiles/CMakeDirectoryInformation.cmake

@@ -1,16 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Relative path conversion top directories.
-set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/hello_user/hashmap-bench")
-set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/hello_user/hashmap-bench")
-
-# Force unix paths in dependencies.
-set(CMAKE_FORCE_UNIX_PATHS 1)
-
-
-# The C and CXX include file regular expressions for this directory.
-set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
-set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
-set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
-set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})

src/includes/3thparty/tsl/CMakeFiles/progress.marks

@@ -1 +0,0 @@
-97

src/includes/3thparty/tsl/Makefile

@@ -1,151 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Default target executed when no arguments are given to make.
-default_target: all
-
-.PHONY : default_target
-
-# Allow only one "make -f Makefile2" at a time, but pass parallelism.
-.NOTPARALLEL:
-
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-
-# Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-
-# A target that is always out of date.
-cmake_force:
-
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/hello_user/hashmap-bench
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
-
-#=============================================================================
-# Targets provided globally by CMake.
-
-# Special rule for the target rebuild_cache
-rebuild_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
-	/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : rebuild_cache
-
-# Special rule for the target rebuild_cache
-rebuild_cache/fast: rebuild_cache
-
-.PHONY : rebuild_cache/fast
-
-# Special rule for the target edit_cache
-edit_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
-	/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : edit_cache
-
-# Special rule for the target edit_cache
-edit_cache/fast: edit_cache
-
-.PHONY : edit_cache/fast
-
-# The main all target
-all: cmake_check_build_system
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/CMakeFiles/progress.marks
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/all
-	$(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles 0
-.PHONY : all
-
-# The main clean target
-clean:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/clean
-.PHONY : clean
-
-# The main clean target
-clean/fast: clean
-
-.PHONY : clean/fast
-
-# Prepare targets for installation.
-preinstall: all
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/preinstall
-.PHONY : preinstall
-
-# Prepare targets for installation.
-preinstall/fast:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/preinstall
-.PHONY : preinstall/fast
-
-# clear depends
-depend:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
-.PHONY : depend
-
-# Help Target
-help:
-	@echo "The following are some of the valid targets for this Makefile:"
-	@echo "... all (the default if no target is provided)"
-	@echo "... clean"
-	@echo "... depend"
-	@echo "... edit_cache"
-	@echo "... rebuild_cache"
-.PHONY : help
-
-
-
-#=============================================================================
-# Special targets to cleanup operation of make.
-
-# Special rule to run CMake to check the build system integrity.
-# No rule that depends on this can have commands that come from listfiles
-# because they might be regenerated.
-cmake_check_build_system:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
-.PHONY : cmake_check_build_system
-

src/includes/3thparty/tsl/absl/CMakeFiles/CMakeDirectoryInformation.cmake

@@ -1,16 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Relative path conversion top directories.
-set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/hello_user/hashmap-bench")
-set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/hello_user/hashmap-bench")
-
-# Force unix paths in dependencies.
-set(CMAKE_FORCE_UNIX_PATHS 1)
-
-
-# The C and CXX include file regular expressions for this directory.
-set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
-set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
-set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
-set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})

src/includes/3thparty/tsl/absl/CMakeFiles/progress.marks

@@ -1 +0,0 @@
-97

src/includes/3thparty/tsl/absl/Makefile

@@ -1,151 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Default target executed when no arguments are given to make.
-default_target: all
-
-.PHONY : default_target
-
-# Allow only one "make -f Makefile2" at a time, but pass parallelism.
-.NOTPARALLEL:
-
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-
-# Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-
-# A target that is always out of date.
-cmake_force:
-
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/hello_user/hashmap-bench
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
-
-#=============================================================================
-# Targets provided globally by CMake.
-
-# Special rule for the target rebuild_cache
-rebuild_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
-	/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : rebuild_cache
-
-# Special rule for the target rebuild_cache
-rebuild_cache/fast: rebuild_cache
-
-.PHONY : rebuild_cache/fast
-
-# Special rule for the target edit_cache
-edit_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
-	/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : edit_cache
-
-# Special rule for the target edit_cache
-edit_cache/fast: edit_cache
-
-.PHONY : edit_cache/fast
-
-# The main all target
-all: cmake_check_build_system
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/CMakeFiles/progress.marks
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/all
-	$(CMAKE_COMMAND) -E cmake_progress_start /home/hello_user/hashmap-bench/CMakeFiles 0
-.PHONY : all
-
-# The main clean target
-clean:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/clean
-.PHONY : clean
-
-# The main clean target
-clean/fast: clean
-
-.PHONY : clean/fast
-
-# Prepare targets for installation.
-preinstall: all
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/preinstall
-.PHONY : preinstall
-
-# Prepare targets for installation.
-preinstall/fast:
-	cd /home/hello_user/hashmap-bench && $(MAKE) -f CMakeFiles/Makefile2 src/includes/3thparty/tsl/absl/preinstall
-.PHONY : preinstall/fast
-
-# clear depends
-depend:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
-.PHONY : depend
-
-# Help Target
-help:
-	@echo "The following are some of the valid targets for this Makefile:"
-	@echo "... all (the default if no target is provided)"
-	@echo "... clean"
-	@echo "... depend"
-	@echo "... edit_cache"
-	@echo "... rebuild_cache"
-.PHONY : help
-
-
-
-#=============================================================================
-# Special targets to cleanup operation of make.
-
-# Special rule to run CMake to check the build system integrity.
-# No rule that depends on this can have commands that come from listfiles
-# because they might be regenerated.
-cmake_check_build_system:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
-.PHONY : cmake_check_build_system
-

src/includes/3thparty/tsl/absl/algorithm/CMakeFiles/CMakeDirectoryInformation.cmake

@@ -1,16 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Relative path conversion top directories.
-set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/hello_user/hashmap-bench")
-set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/hello_user/hashmap-bench")
-
-# Force unix paths in dependencies.
-set(CMAKE_FORCE_UNIX_PATHS 1)
-
-
-# The C and CXX include file regular expressions for this directory.
-set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
-set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
-set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
-set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})

src/includes/3thparty/tsl/absl/algorithm/CMakeFiles/progress.marks

@@ -1 +0,0 @@
-0

src/includes/3thparty/tsl/absl/algorithm/cmake_install.cmake

@@ -1,39 +0,0 @@
-# Install script for directory: /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/algorithm
-
-# Set the install prefix
-if(NOT DEFINED CMAKE_INSTALL_PREFIX)
-  set(CMAKE_INSTALL_PREFIX "/usr/local")
-endif()
-string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-
-# Set the install configuration name.
-if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
-  if(BUILD_TYPE)
-    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
-           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
-  else()
-    set(CMAKE_INSTALL_CONFIG_NAME "")
-  endif()
-  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
-endif()
-
-# Set the component getting installed.
-if(NOT CMAKE_INSTALL_COMPONENT)
-  if(COMPONENT)
-    message(STATUS "Install component: \"${COMPONENT}\"")
-    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
-  else()
-    set(CMAKE_INSTALL_COMPONENT)
-  endif()
-endif()
-
-# Install shared libraries without execute permission?
-if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
-  set(CMAKE_INSTALL_SO_NO_EXE "0")
-endif()
-
-# Is this installation the result of a crosscompile?
-if(NOT DEFINED CMAKE_CROSSCOMPILING)
-  set(CMAKE_CROSSCOMPILING "FALSE")
-endif()
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/CXX.includecache

@@ -1,368 +0,0 @@
-#IncludeRegexLine: ^[ 	]*[#%][ 	]*(include|import)[ 	]*[<"]([^">]+)([">])
-
-#IncludeRegexScan: ^.*$
-
-#IncludeRegexComplain: ^$
-
-#IncludeRegexTransform: 
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc
-absl/base/internal/cycleclock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/cycleclock.h
-atomic
--
-chrono
--
-absl/base/internal/unscaledcycleclock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/unscaledcycleclock.h
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc
-absl/base/internal/spinlock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/spinlock.h
-algorithm
--
-atomic
--
-limits
--
-absl/base/attributes.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/attributes.h
-absl/base/internal/atomic_hook.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/atomic_hook.h
-absl/base/internal/cycleclock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/cycleclock.h
-absl/base/internal/spinlock_wait.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/spinlock_wait.h
-absl/base/internal/sysinfo.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/sysinfo.h
-absl/base/call_once.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/call_once.h
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc
-absl/base/internal/sysinfo.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/sysinfo.h
-absl/base/attributes.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/attributes.h
-windows.h
--
-fcntl.h
--
-pthread.h
--
-sys/stat.h
--
-sys/types.h
--
-unistd.h
--
-sys/syscall.h
--
-sys/sysctl.h
--
-rtems.h
--
-string.h
--
-cassert
--
-cstdint
--
-cstdio
--
-cstdlib
--
-ctime
--
-limits
--
-thread
--
-utility
--
-vector
--
-absl/base/call_once.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/call_once.h
-absl/base/internal/raw_logging.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/raw_logging.h
-absl/base/internal/spinlock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/spinlock.h
-absl/base/internal/unscaledcycleclock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/unscaledcycleclock.h
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc
-absl/base/internal/thread_identity.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/thread_identity.h
-pthread.h
--
-signal.h
--
-atomic
--
-cassert
--
-memory
--
-absl/base/call_once.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/call_once.h
-absl/base/internal/raw_logging.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/raw_logging.h
-absl/base/internal/spinlock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/spinlock.h
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc
-absl/base/internal/unscaledcycleclock.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/unscaledcycleclock.h
-intrin.h
--
-sys/platform/ppc.h
--
-absl/base/internal/sysinfo.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/sysinfo.h
-
-src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-
-src/includes/3thparty/abseil-cpp/absl/base/call_once.h
-algorithm
--
-atomic
--
-cstdint
--
-type_traits
--
-utility
--
-absl/base/internal/invoke.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/invoke.h
-absl/base/internal/low_level_scheduling.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/low_level_scheduling.h
-absl/base/internal/raw_logging.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/raw_logging.h
-absl/base/internal/scheduling_mode.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/scheduling_mode.h
-absl/base/internal/spinlock_wait.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/spinlock_wait.h
-absl/base/macros.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/macros.h
-absl/base/optimization.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/optimization.h
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/config.h
-limits.h
--
-cstddef
--
-Availability.h
--
-TargetConditionals.h
--
-absl/base/options.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/options.h
-absl/base/policy_checks.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/policy_checks.h
-android/ndk-version.h
--
-
-src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-stddef.h
--
-sanitizer/common_interface_defs.h
--
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
-atomic
--
-cassert
--
-cstdint
--
-utility
--
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/attributes.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/config.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.h
-cstdint
--
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/config.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
-algorithm
--
-type_traits
--
-utility
--
-absl/meta/type_traits.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/meta/type_traits.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
-absl/base/internal/scheduling_mode.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/scheduling_mode.h
-absl/base/macros.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/macros.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/per_thread_tls.h
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
-string
--
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/attributes.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/config.h
-absl/base/internal/atomic_hook.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/atomic_hook.h
-absl/base/log_severity.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/log_severity.h
-absl/base/macros.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/macros.h
-absl/base/optimization.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/optimization.h
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/config.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
-stdint.h
--
-sys/types.h
--
-atomic
--
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/attributes.h
-absl/base/dynamic_annotations.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/dynamic_annotations.h
-absl/base/internal/low_level_scheduling.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/low_level_scheduling.h
-absl/base/internal/raw_logging.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/raw_logging.h
-absl/base/internal/scheduling_mode.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/scheduling_mode.h
-absl/base/internal/tsan_mutex_interface.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/tsan_mutex_interface.h
-absl/base/macros.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/macros.h
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/port.h
-absl/base/thread_annotations.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/thread_annotations.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
-stdint.h
--
-atomic
--
-absl/base/internal/scheduling_mode.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/scheduling_mode.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
-sys/types.h
--
-cstdint
--
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.h
-pthread.h
--
-unistd.h
--
-atomic
--
-cstdint
--
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/config.h
-absl/base/internal/per_thread_tls.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/internal/per_thread_tls.h
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
-sanitizer/tsan_interface.h
--
-
-src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
-cstdint
--
-TargetConditionals.h
--
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/internal/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
-array
--
-ostream
--
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/attributes.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/config.h
-
-src/includes/3thparty/abseil-cpp/absl/base/macros.h
-cassert
--
-cstddef
--
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/attributes.h
-absl/base/optimization.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/optimization.h
-absl/base/port.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/port.h
-
-src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/config.h
-intrin.h
--
-
-src/includes/3thparty/abseil-cpp/absl/base/options.h
-ciso646
--
-
-src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-limits.h
--
-cstddef
--
-
-src/includes/3thparty/abseil-cpp/absl/base/port.h
-absl/base/attributes.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/attributes.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/config.h
-absl/base/optimization.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/optimization.h
-
-src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/config.h
-absl/base/internal/thread_annotations.h
-src/includes/3thparty/abseil-cpp/absl/base/absl/base/internal/thread_annotations.h
-
-src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-stddef.h
--
-functional
--
-type_traits
--
-absl/base/config.h
-src/includes/3thparty/abseil-cpp/absl/meta/absl/base/config.h
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/DependInfo.cmake

@@ -1,34 +0,0 @@
-# The set of languages for which implicit dependencies are needed:
-set(CMAKE_DEPENDS_LANGUAGES
-  "CXX"
-  )
-# The set of files for implicit dependencies of each language:
-set(CMAKE_DEPENDS_CHECK_CXX
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o"
-  )
-set(CMAKE_CXX_COMPILER_ID "GNU")
-
-# Preprocessor definitions for this target.
-set(CMAKE_TARGET_DEFINITIONS_CXX
-  "__CLANG_SUPPORT_DYN_ANNOTATION__"
-  )
-
-# The include file search paths:
-set(CMAKE_CXX_TARGET_INCLUDE_PATH
-  "src/includes/3thparty/abseil-cpp"
-  )
-
-# Targets to which this target links.
-set(CMAKE_TARGET_LINKED_INFO_FILES
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/DependInfo.cmake"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_log_severity.dir/DependInfo.cmake"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_raw_logging_internal.dir/DependInfo.cmake"
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_spinlock_wait.dir/DependInfo.cmake"
-  )
-
-# Fortran module output directory.
-set(CMAKE_Fortran_TARGET_MODULE_DIR "")

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/build.make

@@ -1,176 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Delete rule output on recipe failure.
-.DELETE_ON_ERROR:
-
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-
-# Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-
-# A target that is always out of date.
-cmake_force:
-
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/hello_user/hashmap-bench
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
-
-# Include any dependencies generated for this target.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/depend.make
-
-# Include the progress variables for this target.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/progress.make
-
-# Include the compile flags for this target's objects.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_base.dir/internal/cycleclock.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_base.dir/internal/cycleclock.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc > CMakeFiles/absl_base.dir/internal/cycleclock.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_base.dir/internal/cycleclock.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc -o CMakeFiles/absl_base.dir/internal/cycleclock.cc.s
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_base.dir/internal/spinlock.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_base.dir/internal/spinlock.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc > CMakeFiles/absl_base.dir/internal/spinlock.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_base.dir/internal/spinlock.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc -o CMakeFiles/absl_base.dir/internal/spinlock.cc.s
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_base.dir/internal/sysinfo.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_base.dir/internal/sysinfo.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc > CMakeFiles/absl_base.dir/internal/sysinfo.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_base.dir/internal/sysinfo.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc -o CMakeFiles/absl_base.dir/internal/sysinfo.cc.s
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_base.dir/internal/thread_identity.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_base.dir/internal/thread_identity.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc > CMakeFiles/absl_base.dir/internal/thread_identity.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_base.dir/internal/thread_identity.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc -o CMakeFiles/absl_base.dir/internal/thread_identity.cc.s
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc > CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc -o CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.s
-
-# Object files for target absl_base
-absl_base_OBJECTS = \
-"CMakeFiles/absl_base.dir/internal/cycleclock.cc.o" \
-"CMakeFiles/absl_base.dir/internal/spinlock.cc.o" \
-"CMakeFiles/absl_base.dir/internal/sysinfo.cc.o" \
-"CMakeFiles/absl_base.dir/internal/thread_identity.cc.o" \
-"CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o"
-
-# External object files for target absl_base
-absl_base_EXTERNAL_OBJECTS =
-
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/build.make
-src/includes/3thparty/tsl/absl/base/libabsl_base.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/link.txt
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Linking CXX static library libabsl_base.a"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -P CMakeFiles/absl_base.dir/cmake_clean_target.cmake
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/absl_base.dir/link.txt --verbose=$(VERBOSE)
-
-# Rule to build all files generated by this target.
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/build: src/includes/3thparty/tsl/absl/base/libabsl_base.a
-
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/build
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/clean:
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -P CMakeFiles/absl_base.dir/cmake_clean.cmake
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/clean
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/depend:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/hello_user/hashmap-bench /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base /home/hello_user/hashmap-bench /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/DependInfo.cmake --color=$(COLOR)
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/depend
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/cmake_clean.cmake

@@ -1,14 +0,0 @@
-file(REMOVE_RECURSE
-  "CMakeFiles/absl_base.dir/internal/cycleclock.cc.o"
-  "CMakeFiles/absl_base.dir/internal/spinlock.cc.o"
-  "CMakeFiles/absl_base.dir/internal/sysinfo.cc.o"
-  "CMakeFiles/absl_base.dir/internal/thread_identity.cc.o"
-  "CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o"
-  "libabsl_base.a"
-  "libabsl_base.pdb"
-)
-
-# Per-language clean rules from dependency scanning.
-foreach(lang CXX)
-  include(CMakeFiles/absl_base.dir/cmake_clean_${lang}.cmake OPTIONAL)
-endforeach()

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/cmake_clean_target.cmake

@@ -1,3 +0,0 @@
-file(REMOVE_RECURSE
-  "libabsl_base.a"
-)

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/depend.internal

@@ -1,98 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc
- src/includes/3thparty/abseil-cpp/absl/base/attributes.h
- src/includes/3thparty/abseil-cpp/absl/base/config.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
- src/includes/3thparty/abseil-cpp/absl/base/optimization.h
- src/includes/3thparty/abseil-cpp/absl/base/options.h
- src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
- src/includes/3thparty/abseil-cpp/absl/base/port.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc
- src/includes/3thparty/abseil-cpp/absl/base/attributes.h
- src/includes/3thparty/abseil-cpp/absl/base/call_once.h
- src/includes/3thparty/abseil-cpp/absl/base/config.h
- src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
- src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
- src/includes/3thparty/abseil-cpp/absl/base/macros.h
- src/includes/3thparty/abseil-cpp/absl/base/optimization.h
- src/includes/3thparty/abseil-cpp/absl/base/options.h
- src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
- src/includes/3thparty/abseil-cpp/absl/base/port.h
- src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc
- src/includes/3thparty/abseil-cpp/absl/base/attributes.h
- src/includes/3thparty/abseil-cpp/absl/base/call_once.h
- src/includes/3thparty/abseil-cpp/absl/base/config.h
- src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
- src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
- src/includes/3thparty/abseil-cpp/absl/base/macros.h
- src/includes/3thparty/abseil-cpp/absl/base/optimization.h
- src/includes/3thparty/abseil-cpp/absl/base/options.h
- src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
- src/includes/3thparty/abseil-cpp/absl/base/port.h
- src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc
- src/includes/3thparty/abseil-cpp/absl/base/attributes.h
- src/includes/3thparty/abseil-cpp/absl/base/call_once.h
- src/includes/3thparty/abseil-cpp/absl/base/config.h
- src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/per_thread_tls.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
- src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
- src/includes/3thparty/abseil-cpp/absl/base/macros.h
- src/includes/3thparty/abseil-cpp/absl/base/optimization.h
- src/includes/3thparty/abseil-cpp/absl/base/options.h
- src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
- src/includes/3thparty/abseil-cpp/absl/base/port.h
- src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
- src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc
- src/includes/3thparty/abseil-cpp/absl/base/attributes.h
- src/includes/3thparty/abseil-cpp/absl/base/config.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
- src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
- src/includes/3thparty/abseil-cpp/absl/base/optimization.h
- src/includes/3thparty/abseil-cpp/absl/base/options.h
- src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
- src/includes/3thparty/abseil-cpp/absl/base/port.h

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/depend.make

@@ -1,98 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/config.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/options.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/cycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/port.h
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/call_once.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/config.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/cycleclock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/macros.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/options.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/port.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/spinlock.cc.o: src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/call_once.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/config.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/macros.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/options.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/port.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/sysinfo.cc.o: src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/call_once.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/config.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/atomic_hook.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/invoke.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/low_level_scheduling.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/per_thread_tls.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/raw_logging.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/scheduling_mode.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/spinlock_wait.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/thread_identity.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/tsan_mutex_interface.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/log_severity.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/macros.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/options.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/port.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/base/thread_annotations.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/thread_identity.cc.o: src/includes/3thparty/abseil-cpp/absl/meta/type_traits.h
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/attributes.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/config.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/sysinfo.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/internal/unscaledcycleclock.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/optimization.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/options.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/policy_checks.h
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o: src/includes/3thparty/abseil-cpp/absl/base/port.h
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/flags.make

@@ -1,10 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# compile CXX with /usr/bin/c++
-CXX_FLAGS = -O3 -flto=thin -march=native   -Wall -Wextra -Wcast-qual -Wconversion-null -Wmissing-declarations -Woverlength-strings -Wpointer-arith -Wunused-local-typedefs -Wunused-result -Wvarargs -Wvla -Wwrite-strings -Wno-missing-field-initializers -Wno-sign-compare -std=gnu++17
-
-CXX_DEFINES = -D__CLANG_SUPPORT_DYN_ANNOTATION__
-
-CXX_INCLUDES = -I/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp 
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/link.txt

@@ -1,2 +0,0 @@
-/usr/bin/ar qc libabsl_base.a  CMakeFiles/absl_base.dir/internal/cycleclock.cc.o CMakeFiles/absl_base.dir/internal/spinlock.cc.o CMakeFiles/absl_base.dir/internal/sysinfo.cc.o CMakeFiles/absl_base.dir/internal/thread_identity.cc.o CMakeFiles/absl_base.dir/internal/unscaledcycleclock.cc.o
-/usr/bin/ranlib libabsl_base.a

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_base.dir/progress.make

@@ -1,7 +0,0 @@
-CMAKE_PROGRESS_1 = 4
-CMAKE_PROGRESS_2 = 5
-CMAKE_PROGRESS_3 = 
-CMAKE_PROGRESS_4 = 6
-CMAKE_PROGRESS_5 = 7
-CMAKE_PROGRESS_6 = 
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/CXX.includecache

@@ -1,24 +0,0 @@
-#IncludeRegexLine: ^[ 	]*[#%][ 	]*(include|import)[ 	]*[<"]([^">]+)([">])
-
-#IncludeRegexScan: ^.*$
-
-#IncludeRegexComplain: ^$
-
-#IncludeRegexTransform: 
-
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc
-stdlib.h
--
-string.h
--
-absl/base/dynamic_annotations.h
-/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/absl/base/dynamic_annotations.h
-sanitizer/msan_interface.h
--
-
-src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-stddef.h
--
-sanitizer/common_interface_defs.h
--
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/DependInfo.cmake

@@ -1,26 +0,0 @@
-# The set of languages for which implicit dependencies are needed:
-set(CMAKE_DEPENDS_LANGUAGES
-  "CXX"
-  )
-# The set of files for implicit dependencies of each language:
-set(CMAKE_DEPENDS_CHECK_CXX
-  "/home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc" "/home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o"
-  )
-set(CMAKE_CXX_COMPILER_ID "GNU")
-
-# Preprocessor definitions for this target.
-set(CMAKE_TARGET_DEFINITIONS_CXX
-  "__CLANG_SUPPORT_DYN_ANNOTATION__"
-  )
-
-# The include file search paths:
-set(CMAKE_CXX_TARGET_INCLUDE_PATH
-  "src/includes/3thparty/abseil-cpp"
-  )
-
-# Targets to which this target links.
-set(CMAKE_TARGET_LINKED_INFO_FILES
-  )
-
-# Fortran module output directory.
-set(CMAKE_Fortran_TARGET_MODULE_DIR "")

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/build.make

@@ -1,116 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-# Delete rule output on recipe failure.
-.DELETE_ON_ERROR:
-
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-
-# Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-
-# A target that is always out of date.
-cmake_force:
-
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/hello_user/hashmap-bench
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/hello_user/hashmap-bench
-
-# Include any dependencies generated for this target.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/depend.make
-
-# Include the progress variables for this target.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/progress.make
-
-# Include the compile flags for this target's objects.
-include src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/flags.make
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/flags.make
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o -c /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.i"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc > CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.i
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.s"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc -o CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.s
-
-# Object files for target absl_dynamic_annotations
-absl_dynamic_annotations_OBJECTS = \
-"CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o"
-
-# External object files for target absl_dynamic_annotations
-absl_dynamic_annotations_EXTERNAL_OBJECTS =
-
-src/includes/3thparty/tsl/absl/base/libabsl_dynamic_annotations.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o
-src/includes/3thparty/tsl/absl/base/libabsl_dynamic_annotations.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/build.make
-src/includes/3thparty/tsl/absl/base/libabsl_dynamic_annotations.a: src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/link.txt
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/hello_user/hashmap-bench/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX static library libabsl_dynamic_annotations.a"
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -P CMakeFiles/absl_dynamic_annotations.dir/cmake_clean_target.cmake
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/absl_dynamic_annotations.dir/link.txt --verbose=$(VERBOSE)
-
-# Rule to build all files generated by this target.
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/build: src/includes/3thparty/tsl/absl/base/libabsl_dynamic_annotations.a
-
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/build
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/clean:
-	cd /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base && $(CMAKE_COMMAND) -P CMakeFiles/absl_dynamic_annotations.dir/cmake_clean.cmake
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/clean
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/depend:
-	cd /home/hello_user/hashmap-bench && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/hello_user/hashmap-bench /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base /home/hello_user/hashmap-bench /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base /home/hello_user/hashmap-bench/src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/DependInfo.cmake --color=$(COLOR)
-.PHONY : src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/depend
-

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/cmake_clean.cmake

@@ -1,10 +0,0 @@
-file(REMOVE_RECURSE
-  "CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o"
-  "libabsl_dynamic_annotations.a"
-  "libabsl_dynamic_annotations.pdb"
-)
-
-# Per-language clean rules from dependency scanning.
-foreach(lang CXX)
-  include(CMakeFiles/absl_dynamic_annotations.dir/cmake_clean_${lang}.cmake OPTIONAL)
-endforeach()

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/cmake_clean_target.cmake

@@ -1,3 +0,0 @@
-file(REMOVE_RECURSE
-  "libabsl_dynamic_annotations.a"
-)

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/depend.internal

@@ -1,6 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o
- /home/hello_user/hashmap-bench/src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc
- src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h

src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/depend.make

@@ -1,6 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.17
-
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.cc
-src/includes/3thparty/tsl/absl/base/CMakeFiles/absl_dynamic_annotations.dir/dynamic_annotations.cc.o: src/includes/3thparty/abseil-cpp/absl/base/dynamic_annotations.h
-