Full Code of redis-io/redis for AI

gitextract_z3mis2y8/

├── .codespell/
│   ├── .codespellrc
│   ├── requirements.txt
│   └── wordlist.txt
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── crash_report.md
│   │   ├── feature_request.md
│   │   ├── other_stuff.md
│   │   └── question.md
│   ├── dependabot.yml
│   └── workflows/
│       ├── ci.yml
│       ├── codecov.yml
│       ├── codeql-analysis.yml
│       ├── coverity.yml
│       ├── daily.yml
│       ├── external.yml
│       ├── post-release-automation.yml
│       ├── redis_docs_sync.yaml
│       ├── reply-schemas-linter.yml
│       └── spell-check.yml
├── .gitignore
├── 00-RELEASENOTES
├── BUGS
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── INSTALL
├── LICENSE.txt
├── MANIFESTO
├── Makefile
├── README.md
├── REDISCONTRIBUTIONS.txt
├── SECURITY.md
├── TLS.md
├── codecov.yml
├── deps/
│   ├── Makefile
│   ├── README.md
│   ├── fpconv/
│   │   ├── LICENSE.txt
│   │   ├── Makefile
│   │   ├── README.md
│   │   ├── fpconv_dtoa.c
│   │   ├── fpconv_dtoa.h
│   │   └── fpconv_powers.h
│   ├── hdr_histogram/
│   │   ├── COPYING.txt
│   │   ├── LICENSE.txt
│   │   ├── Makefile
│   │   ├── README.md
│   │   ├── hdr_atomic.h
│   │   ├── hdr_histogram.c
│   │   ├── hdr_histogram.h
│   │   ├── hdr_redis_malloc.h
│   │   └── hdr_tests.h
│   ├── hiredis/
│   │   ├── .github/
│   │   │   ├── release-drafter-config.yml
│   │   │   └── workflows/
│   │   │       ├── build.yml
│   │   │       ├── release-drafter.yml
│   │   │       └── test.yml
│   │   ├── .gitignore
│   │   ├── .travis.yml
│   │   ├── CHANGELOG.md
│   │   ├── CMakeLists.txt
│   │   ├── COPYING
│   │   ├── Makefile
│   │   ├── README.md
│   │   ├── adapters/
│   │   │   ├── ae.h
│   │   │   ├── glib.h
│   │   │   ├── ivykis.h
│   │   │   ├── libev.h
│   │   │   ├── libevent.h
│   │   │   ├── libhv.h
│   │   │   ├── libsdevent.h
│   │   │   ├── libuv.h
│   │   │   ├── macosx.h
│   │   │   ├── poll.h
│   │   │   ├── qt.h
│   │   │   └── redismoduleapi.h
│   │   ├── alloc.c
│   │   ├── alloc.h
│   │   ├── appveyor.yml
│   │   ├── async.c
│   │   ├── async.h
│   │   ├── async_private.h
│   │   ├── dict.c
│   │   ├── dict.h
│   │   ├── examples/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── example-ae.c
│   │   │   ├── example-glib.c
│   │   │   ├── example-ivykis.c
│   │   │   ├── example-libev.c
│   │   │   ├── example-libevent-ssl.c
│   │   │   ├── example-libevent.c
│   │   │   ├── example-libhv.c
│   │   │   ├── example-libsdevent.c
│   │   │   ├── example-libuv.c
│   │   │   ├── example-macosx.c
│   │   │   ├── example-poll.c
│   │   │   ├── example-push.c
│   │   │   ├── example-qt.cpp
│   │   │   ├── example-qt.h
│   │   │   ├── example-redismoduleapi.c
│   │   │   ├── example-ssl.c
│   │   │   └── example.c
│   │   ├── fmacros.h
│   │   ├── fuzzing/
│   │   │   └── format_command_fuzzer.c
│   │   ├── hiredis-config.cmake.in
│   │   ├── hiredis.c
│   │   ├── hiredis.h
│   │   ├── hiredis.pc.in
│   │   ├── hiredis.targets
│   │   ├── hiredis_ssl-config.cmake.in
│   │   ├── hiredis_ssl.h
│   │   ├── hiredis_ssl.pc.in
│   │   ├── net.c
│   │   ├── net.h
│   │   ├── read.c
│   │   ├── read.h
│   │   ├── sds.c
│   │   ├── sds.h
│   │   ├── sdsalloc.h
│   │   ├── sdscompat.h
│   │   ├── sockcompat.c
│   │   ├── sockcompat.h
│   │   ├── ssl.c
│   │   ├── test.c
│   │   ├── test.sh
│   │   └── win32.h
│   ├── jemalloc/
│   │   ├── .appveyor.yml
│   │   ├── .autom4te.cfg
│   │   ├── .cirrus.yml
│   │   ├── .clang-format
│   │   ├── .gitattributes
│   │   ├── .gitignore
│   │   ├── .travis.yml
│   │   ├── COPYING
│   │   ├── ChangeLog
│   │   ├── INSTALL.md
│   │   ├── Makefile.in
│   │   ├── README
│   │   ├── TUNING.md
│   │   ├── VERSION
│   │   ├── autogen.sh
│   │   ├── bin/
│   │   │   ├── jemalloc-config.in
│   │   │   ├── jemalloc.sh.in
│   │   │   └── jeprof.in
│   │   ├── build-aux/
│   │   │   ├── config.guess
│   │   │   ├── config.sub
│   │   │   └── install-sh
│   │   ├── config.stamp.in
│   │   ├── configure
│   │   ├── configure.ac
│   │   ├── doc/
│   │   │   ├── html.xsl.in
│   │   │   ├── jemalloc.xml.in
│   │   │   ├── manpages.xsl.in
│   │   │   └── stylesheet.xsl
│   │   ├── doc_internal/
│   │   │   └── PROFILING_INTERNALS.md
│   │   ├── include/
│   │   │   ├── jemalloc/
│   │   │   │   ├── internal/
│   │   │   │   │   ├── activity_callback.h
│   │   │   │   │   ├── arena_externs.h
│   │   │   │   │   ├── arena_inlines_a.h
│   │   │   │   │   ├── arena_inlines_b.h
│   │   │   │   │   ├── arena_stats.h
│   │   │   │   │   ├── arena_structs.h
│   │   │   │   │   ├── arena_types.h
│   │   │   │   │   ├── assert.h
│   │   │   │   │   ├── atomic.h
│   │   │   │   │   ├── atomic_c11.h
│   │   │   │   │   ├── atomic_gcc_atomic.h
│   │   │   │   │   ├── atomic_gcc_sync.h
│   │   │   │   │   ├── atomic_msvc.h
│   │   │   │   │   ├── background_thread_externs.h
│   │   │   │   │   ├── background_thread_inlines.h
│   │   │   │   │   ├── background_thread_structs.h
│   │   │   │   │   ├── base.h
│   │   │   │   │   ├── bin.h
│   │   │   │   │   ├── bin_info.h
│   │   │   │   │   ├── bin_stats.h
│   │   │   │   │   ├── bin_types.h
│   │   │   │   │   ├── bit_util.h
│   │   │   │   │   ├── bitmap.h
│   │   │   │   │   ├── buf_writer.h
│   │   │   │   │   ├── cache_bin.h
│   │   │   │   │   ├── ckh.h
│   │   │   │   │   ├── counter.h
│   │   │   │   │   ├── ctl.h
│   │   │   │   │   ├── decay.h
│   │   │   │   │   ├── div.h
│   │   │   │   │   ├── ecache.h
│   │   │   │   │   ├── edata.h
│   │   │   │   │   ├── edata_cache.h
│   │   │   │   │   ├── ehooks.h
│   │   │   │   │   ├── emap.h
│   │   │   │   │   ├── emitter.h
│   │   │   │   │   ├── eset.h
│   │   │   │   │   ├── exp_grow.h
│   │   │   │   │   ├── extent.h
│   │   │   │   │   ├── extent_dss.h
│   │   │   │   │   ├── extent_mmap.h
│   │   │   │   │   ├── fb.h
│   │   │   │   │   ├── fxp.h
│   │   │   │   │   ├── hash.h
│   │   │   │   │   ├── hook.h
│   │   │   │   │   ├── hpa.h
│   │   │   │   │   ├── hpa_hooks.h
│   │   │   │   │   ├── hpa_opts.h
│   │   │   │   │   ├── hpdata.h
│   │   │   │   │   ├── inspect.h
│   │   │   │   │   ├── jemalloc_internal_decls.h
│   │   │   │   │   ├── jemalloc_internal_defs.h.in
│   │   │   │   │   ├── jemalloc_internal_externs.h
│   │   │   │   │   ├── jemalloc_internal_includes.h
│   │   │   │   │   ├── jemalloc_internal_inlines_a.h
│   │   │   │   │   ├── jemalloc_internal_inlines_b.h
│   │   │   │   │   ├── jemalloc_internal_inlines_c.h
│   │   │   │   │   ├── jemalloc_internal_macros.h
│   │   │   │   │   ├── jemalloc_internal_types.h
│   │   │   │   │   ├── jemalloc_preamble.h.in
│   │   │   │   │   ├── large_externs.h
│   │   │   │   │   ├── lockedint.h
│   │   │   │   │   ├── log.h
│   │   │   │   │   ├── malloc_io.h
│   │   │   │   │   ├── mpsc_queue.h
│   │   │   │   │   ├── mutex.h
│   │   │   │   │   ├── mutex_prof.h
│   │   │   │   │   ├── nstime.h
│   │   │   │   │   ├── pa.h
│   │   │   │   │   ├── pac.h
│   │   │   │   │   ├── pages.h
│   │   │   │   │   ├── pai.h
│   │   │   │   │   ├── peak.h
│   │   │   │   │   ├── peak_event.h
│   │   │   │   │   ├── ph.h
│   │   │   │   │   ├── private_namespace.sh
│   │   │   │   │   ├── private_symbols.sh
│   │   │   │   │   ├── prng.h
│   │   │   │   │   ├── prof_data.h
│   │   │   │   │   ├── prof_externs.h
│   │   │   │   │   ├── prof_hook.h
│   │   │   │   │   ├── prof_inlines.h
│   │   │   │   │   ├── prof_log.h
│   │   │   │   │   ├── prof_recent.h
│   │   │   │   │   ├── prof_stats.h
│   │   │   │   │   ├── prof_structs.h
│   │   │   │   │   ├── prof_sys.h
│   │   │   │   │   ├── prof_types.h
│   │   │   │   │   ├── psset.h
│   │   │   │   │   ├── public_namespace.sh
│   │   │   │   │   ├── public_unnamespace.sh
│   │   │   │   │   ├── ql.h
│   │   │   │   │   ├── qr.h
│   │   │   │   │   ├── quantum.h
│   │   │   │   │   ├── rb.h
│   │   │   │   │   ├── rtree.h
│   │   │   │   │   ├── rtree_tsd.h
│   │   │   │   │   ├── safety_check.h
│   │   │   │   │   ├── san.h
│   │   │   │   │   ├── san_bump.h
│   │   │   │   │   ├── sc.h
│   │   │   │   │   ├── sec.h
│   │   │   │   │   ├── sec_opts.h
│   │   │   │   │   ├── seq.h
│   │   │   │   │   ├── slab_data.h
│   │   │   │   │   ├── smoothstep.h
│   │   │   │   │   ├── smoothstep.sh
│   │   │   │   │   ├── spin.h
│   │   │   │   │   ├── stats.h
│   │   │   │   │   ├── sz.h
│   │   │   │   │   ├── tcache_externs.h
│   │   │   │   │   ├── tcache_inlines.h
│   │   │   │   │   ├── tcache_structs.h
│   │   │   │   │   ├── tcache_types.h
│   │   │   │   │   ├── test_hooks.h
│   │   │   │   │   ├── thread_event.h
│   │   │   │   │   ├── ticker.h
│   │   │   │   │   ├── tsd.h
│   │   │   │   │   ├── tsd_generic.h
│   │   │   │   │   ├── tsd_malloc_thread_cleanup.h
│   │   │   │   │   ├── tsd_tls.h
│   │   │   │   │   ├── tsd_types.h
│   │   │   │   │   ├── tsd_win.h
│   │   │   │   │   ├── typed_list.h
│   │   │   │   │   ├── util.h
│   │   │   │   │   └── witness.h
│   │   │   │   ├── jemalloc.sh
│   │   │   │   ├── jemalloc_defs.h.in
│   │   │   │   ├── jemalloc_macros.h.in
│   │   │   │   ├── jemalloc_mangle.sh
│   │   │   │   ├── jemalloc_protos.h.in
│   │   │   │   ├── jemalloc_rename.sh
│   │   │   │   └── jemalloc_typedefs.h.in
│   │   │   └── msvc_compat/
│   │   │       ├── C99/
│   │   │       │   ├── stdbool.h
│   │   │       │   └── stdint.h
│   │   │       ├── strings.h
│   │   │       └── windows_extra.h
│   │   ├── jemalloc.pc.in
│   │   ├── m4/
│   │   │   └── ax_cxx_compile_stdcxx.m4
│   │   ├── msvc/
│   │   │   ├── ReadMe.txt
│   │   │   ├── jemalloc_vc2015.sln
│   │   │   ├── jemalloc_vc2017.sln
│   │   │   ├── projects/
│   │   │   │   ├── vc2015/
│   │   │   │   │   ├── jemalloc/
│   │   │   │   │   │   ├── jemalloc.vcxproj
│   │   │   │   │   │   └── jemalloc.vcxproj.filters
│   │   │   │   │   └── test_threads/
│   │   │   │   │       ├── test_threads.vcxproj
│   │   │   │   │       └── test_threads.vcxproj.filters
│   │   │   │   └── vc2017/
│   │   │   │       ├── jemalloc/
│   │   │   │       │   ├── jemalloc.vcxproj
│   │   │   │       │   └── jemalloc.vcxproj.filters
│   │   │   │       └── test_threads/
│   │   │   │           ├── test_threads.vcxproj
│   │   │   │           └── test_threads.vcxproj.filters
│   │   │   └── test_threads/
│   │   │       ├── test_threads.cpp
│   │   │       ├── test_threads.h
│   │   │       └── test_threads_main.cpp
│   │   ├── run_tests.sh
│   │   ├── scripts/
│   │   │   ├── check-formatting.sh
│   │   │   ├── freebsd/
│   │   │   │   ├── before_install.sh
│   │   │   │   ├── before_script.sh
│   │   │   │   └── script.sh
│   │   │   ├── gen_run_tests.py
│   │   │   ├── gen_travis.py
│   │   │   ├── linux/
│   │   │   │   └── before_install.sh
│   │   │   └── windows/
│   │   │       ├── before_install.sh
│   │   │       ├── before_script.sh
│   │   │       └── script.sh
│   │   ├── src/
│   │   │   ├── arena.c
│   │   │   ├── background_thread.c
│   │   │   ├── base.c
│   │   │   ├── bin.c
│   │   │   ├── bin_info.c
│   │   │   ├── bitmap.c
│   │   │   ├── buf_writer.c
│   │   │   ├── cache_bin.c
│   │   │   ├── ckh.c
│   │   │   ├── counter.c
│   │   │   ├── ctl.c
│   │   │   ├── decay.c
│   │   │   ├── div.c
│   │   │   ├── ecache.c
│   │   │   ├── edata.c
│   │   │   ├── edata_cache.c
│   │   │   ├── ehooks.c
│   │   │   ├── emap.c
│   │   │   ├── eset.c
│   │   │   ├── exp_grow.c
│   │   │   ├── extent.c
│   │   │   ├── extent_dss.c
│   │   │   ├── extent_mmap.c
│   │   │   ├── fxp.c
│   │   │   ├── hook.c
│   │   │   ├── hpa.c
│   │   │   ├── hpa_hooks.c
│   │   │   ├── hpdata.c
│   │   │   ├── inspect.c
│   │   │   ├── jemalloc.c
│   │   │   ├── jemalloc_cpp.cpp
│   │   │   ├── large.c
│   │   │   ├── log.c
│   │   │   ├── malloc_io.c
│   │   │   ├── mutex.c
│   │   │   ├── nstime.c
│   │   │   ├── pa.c
│   │   │   ├── pa_extra.c
│   │   │   ├── pac.c
│   │   │   ├── pages.c
│   │   │   ├── pai.c
│   │   │   ├── peak_event.c
│   │   │   ├── prof.c
│   │   │   ├── prof_data.c
│   │   │   ├── prof_log.c
│   │   │   ├── prof_recent.c
│   │   │   ├── prof_stats.c
│   │   │   ├── prof_sys.c
│   │   │   ├── psset.c
│   │   │   ├── rtree.c
│   │   │   ├── safety_check.c
│   │   │   ├── san.c
│   │   │   ├── san_bump.c
│   │   │   ├── sc.c
│   │   │   ├── sec.c
│   │   │   ├── stats.c
│   │   │   ├── sz.c
│   │   │   ├── tcache.c
│   │   │   ├── test_hooks.c
│   │   │   ├── thread_event.c
│   │   │   ├── ticker.c
│   │   │   ├── ticker.py
│   │   │   ├── tsd.c
│   │   │   ├── witness.c
│   │   │   └── zone.c
│   │   └── test/
│   │       ├── analyze/
│   │       │   ├── prof_bias.c
│   │       │   ├── rand.c
│   │       │   └── sizes.c
│   │       ├── include/
│   │       │   └── test/
│   │       │       ├── SFMT-alti.h
│   │       │       ├── SFMT-params.h
│   │       │       ├── SFMT-params11213.h
│   │       │       ├── SFMT-params1279.h
│   │       │       ├── SFMT-params132049.h
│   │       │       ├── SFMT-params19937.h
│   │       │       ├── SFMT-params216091.h
│   │       │       ├── SFMT-params2281.h
│   │       │       ├── SFMT-params4253.h
│   │       │       ├── SFMT-params44497.h
│   │       │       ├── SFMT-params607.h
│   │       │       ├── SFMT-params86243.h
│   │       │       ├── SFMT-sse2.h
│   │       │       ├── SFMT.h
│   │       │       ├── arena_util.h
│   │       │       ├── bench.h
│   │       │       ├── bgthd.h
│   │       │       ├── btalloc.h
│   │       │       ├── extent_hooks.h
│   │       │       ├── jemalloc_test.h.in
│   │       │       ├── jemalloc_test_defs.h.in
│   │       │       ├── math.h
│   │       │       ├── mq.h
│   │       │       ├── mtx.h
│   │       │       ├── nbits.h
│   │       │       ├── san.h
│   │       │       ├── sleep.h
│   │       │       ├── test.h
│   │       │       ├── thd.h
│   │       │       └── timer.h
│   │       ├── integration/
│   │       │   ├── MALLOCX_ARENA.c
│   │       │   ├── aligned_alloc.c
│   │       │   ├── allocated.c
│   │       │   ├── cpp/
│   │       │   │   ├── basic.cpp
│   │       │   │   ├── infallible_new_false.cpp
│   │       │   │   ├── infallible_new_false.sh
│   │       │   │   ├── infallible_new_true.cpp
│   │       │   │   └── infallible_new_true.sh
│   │       │   ├── extent.c
│   │       │   ├── extent.sh
│   │       │   ├── malloc.c
│   │       │   ├── mallocx.c
│   │       │   ├── mallocx.sh
│   │       │   ├── overflow.c
│   │       │   ├── posix_memalign.c
│   │       │   ├── rallocx.c
│   │       │   ├── sdallocx.c
│   │       │   ├── slab_sizes.c
│   │       │   ├── slab_sizes.sh
│   │       │   ├── smallocx.c
│   │       │   ├── smallocx.sh
│   │       │   ├── thread_arena.c
│   │       │   ├── thread_tcache_enabled.c
│   │       │   ├── xallocx.c
│   │       │   └── xallocx.sh
│   │       ├── src/
│   │       │   ├── SFMT.c
│   │       │   ├── btalloc.c
│   │       │   ├── btalloc_0.c
│   │       │   ├── btalloc_1.c
│   │       │   ├── math.c
│   │       │   ├── mtx.c
│   │       │   ├── sleep.c
│   │       │   ├── test.c
│   │       │   ├── thd.c
│   │       │   └── timer.c
│   │       ├── stress/
│   │       │   ├── batch_alloc.c
│   │       │   ├── fill_flush.c
│   │       │   ├── hookbench.c
│   │       │   ├── large_microbench.c
│   │       │   ├── mallctl.c
│   │       │   └── microbench.c
│   │       ├── test.sh.in
│   │       └── unit/
│   │           ├── SFMT.c
│   │           ├── a0.c
│   │           ├── arena_decay.c
│   │           ├── arena_decay.sh
│   │           ├── arena_reset.c
│   │           ├── arena_reset_prof.c
│   │           ├── arena_reset_prof.sh
│   │           ├── atomic.c
│   │           ├── background_thread.c
│   │           ├── background_thread_enable.c
│   │           ├── base.c
│   │           ├── batch_alloc.c
│   │           ├── batch_alloc.sh
│   │           ├── batch_alloc_prof.c
│   │           ├── batch_alloc_prof.sh
│   │           ├── binshard.c
│   │           ├── binshard.sh
│   │           ├── bit_util.c
│   │           ├── bitmap.c
│   │           ├── buf_writer.c
│   │           ├── cache_bin.c
│   │           ├── ckh.c
│   │           ├── counter.c
│   │           ├── decay.c
│   │           ├── div.c
│   │           ├── double_free.c
│   │           ├── double_free.h
│   │           ├── edata_cache.c
│   │           ├── emitter.c
│   │           ├── extent_quantize.c
│   │           ├── fb.c
│   │           ├── fork.c
│   │           ├── fxp.c
│   │           ├── hash.c
│   │           ├── hook.c
│   │           ├── hpa.c
│   │           ├── hpa_background_thread.c
│   │           ├── hpa_background_thread.sh
│   │           ├── hpdata.c
│   │           ├── huge.c
│   │           ├── inspect.c
│   │           ├── inspect.sh
│   │           ├── junk.c
│   │           ├── junk.sh
│   │           ├── junk_alloc.c
│   │           ├── junk_alloc.sh
│   │           ├── junk_free.c
│   │           ├── junk_free.sh
│   │           ├── log.c
│   │           ├── mallctl.c
│   │           ├── malloc_conf_2.c
│   │           ├── malloc_conf_2.sh
│   │           ├── malloc_io.c
│   │           ├── math.c
│   │           ├── mpsc_queue.c
│   │           ├── mq.c
│   │           ├── mtx.c
│   │           ├── nstime.c
│   │           ├── oversize_threshold.c
│   │           ├── pa.c
│   │           ├── pack.c
│   │           ├── pack.sh
│   │           ├── pages.c
│   │           ├── peak.c
│   │           ├── ph.c
│   │           ├── prng.c
│   │           ├── prof_accum.c
│   │           ├── prof_accum.sh
│   │           ├── prof_active.c
│   │           ├── prof_active.sh
│   │           ├── prof_gdump.c
│   │           ├── prof_gdump.sh
│   │           ├── prof_hook.c
│   │           ├── prof_hook.sh
│   │           ├── prof_idump.c
│   │           ├── prof_idump.sh
│   │           ├── prof_log.c
│   │           ├── prof_log.sh
│   │           ├── prof_mdump.c
│   │           ├── prof_mdump.sh
│   │           ├── prof_recent.c
│   │           ├── prof_recent.sh
│   │           ├── prof_reset.c
│   │           ├── prof_reset.sh
│   │           ├── prof_stats.c
│   │           ├── prof_stats.sh
│   │           ├── prof_sys_thread_name.c
│   │           ├── prof_sys_thread_name.sh
│   │           ├── prof_tctx.c
│   │           ├── prof_tctx.sh
│   │           ├── prof_thread_name.c
│   │           ├── prof_thread_name.sh
│   │           ├── psset.c
│   │           ├── ql.c
│   │           ├── qr.c
│   │           ├── rb.c
│   │           ├── retained.c
│   │           ├── rtree.c
│   │           ├── safety_check.c
│   │           ├── safety_check.sh
│   │           ├── san.c
│   │           ├── san.sh
│   │           ├── san_bump.c
│   │           ├── sc.c
│   │           ├── sec.c
│   │           ├── seq.c
│   │           ├── size_check.c
│   │           ├── size_check.sh
│   │           ├── size_classes.c
│   │           ├── slab.c
│   │           ├── smoothstep.c
│   │           ├── spin.c
│   │           ├── stats.c
│   │           ├── stats_print.c
│   │           ├── sz.c
│   │           ├── tcache_max.c
│   │           ├── tcache_max.sh
│   │           ├── test_hooks.c
│   │           ├── thread_event.c
│   │           ├── thread_event.sh
│   │           ├── ticker.c
│   │           ├── tsd.c
│   │           ├── uaf.c
│   │           ├── witness.c
│   │           ├── zero.c
│   │           ├── zero.sh
│   │           ├── zero_realloc_abort.c
│   │           ├── zero_realloc_abort.sh
│   │           ├── zero_realloc_alloc.c
│   │           ├── zero_realloc_alloc.sh
│   │           ├── zero_realloc_free.c
│   │           ├── zero_realloc_free.sh
│   │           ├── zero_reallocs.c
│   │           └── zero_reallocs.sh
│   ├── linenoise/
│   │   ├── .gitignore
│   │   ├── Makefile
│   │   ├── README.markdown
│   │   ├── example.c
│   │   ├── linenoise.c
│   │   └── linenoise.h
│   ├── lua/
│   │   ├── COPYRIGHT
│   │   ├── HISTORY
│   │   ├── INSTALL
│   │   ├── Makefile
│   │   ├── README
│   │   ├── doc/
│   │   │   ├── contents.html
│   │   │   ├── lua.1
│   │   │   ├── lua.css
│   │   │   ├── lua.html
│   │   │   ├── luac.1
│   │   │   ├── luac.html
│   │   │   ├── manual.css
│   │   │   ├── manual.html
│   │   │   └── readme.html
│   │   ├── etc/
│   │   │   ├── Makefile
│   │   │   ├── README
│   │   │   ├── all.c
│   │   │   ├── lua.hpp
│   │   │   ├── lua.pc
│   │   │   ├── luavs.bat
│   │   │   ├── min.c
│   │   │   ├── noparser.c
│   │   │   └── strict.lua
│   │   ├── src/
│   │   │   ├── Makefile
│   │   │   ├── fpconv.c
│   │   │   ├── fpconv.h
│   │   │   ├── lapi.c
│   │   │   ├── lapi.h
│   │   │   ├── lauxlib.c
│   │   │   ├── lauxlib.h
│   │   │   ├── lbaselib.c
│   │   │   ├── lcode.c
│   │   │   ├── lcode.h
│   │   │   ├── ldblib.c
│   │   │   ├── ldebug.c
│   │   │   ├── ldebug.h
│   │   │   ├── ldo.c
│   │   │   ├── ldo.h
│   │   │   ├── ldump.c
│   │   │   ├── lfunc.c
│   │   │   ├── lfunc.h
│   │   │   ├── lgc.c
│   │   │   ├── lgc.h
│   │   │   ├── linit.c
│   │   │   ├── liolib.c
│   │   │   ├── llex.c
│   │   │   ├── llex.h
│   │   │   ├── llimits.h
│   │   │   ├── lmathlib.c
│   │   │   ├── lmem.c
│   │   │   ├── lmem.h
│   │   │   ├── loadlib.c
│   │   │   ├── lobject.c
│   │   │   ├── lobject.h
│   │   │   ├── lopcodes.c
│   │   │   ├── lopcodes.h
│   │   │   ├── loslib.c
│   │   │   ├── lparser.c
│   │   │   ├── lparser.h
│   │   │   ├── lstate.c
│   │   │   ├── lstate.h
│   │   │   ├── lstring.c
│   │   │   ├── lstring.h
│   │   │   ├── lstrlib.c
│   │   │   ├── ltable.c
│   │   │   ├── ltable.h
│   │   │   ├── ltablib.c
│   │   │   ├── ltm.c
│   │   │   ├── ltm.h
│   │   │   ├── lua.c
│   │   │   ├── lua.h
│   │   │   ├── lua_bit.c
│   │   │   ├── lua_cjson.c
│   │   │   ├── lua_cmsgpack.c
│   │   │   ├── lua_struct.c
│   │   │   ├── luac.c
│   │   │   ├── luaconf.h
│   │   │   ├── lualib.h
│   │   │   ├── lundump.c
│   │   │   ├── lundump.h
│   │   │   ├── lvm.c
│   │   │   ├── lvm.h
│   │   │   ├── lzio.c
│   │   │   ├── lzio.h
│   │   │   ├── print.c
│   │   │   ├── strbuf.c
│   │   │   └── strbuf.h
│   │   └── test/
│   │       ├── README
│   │       ├── bisect.lua
│   │       ├── cf.lua
│   │       ├── echo.lua
│   │       ├── env.lua
│   │       ├── factorial.lua
│   │       ├── fib.lua
│   │       ├── fibfor.lua
│   │       ├── globals.lua
│   │       ├── hello.lua
│   │       ├── life.lua
│   │       ├── luac.lua
│   │       ├── printf.lua
│   │       ├── readonly.lua
│   │       ├── sieve.lua
│   │       ├── sort.lua
│   │       ├── table.lua
│   │       ├── trace-calls.lua
│   │       ├── trace-globals.lua
│   │       └── xd.lua
│   └── xxhash/
│       ├── .gitignore
│       ├── LICENSE
│       ├── Makefile
│       ├── build/
│       │   └── make/
│       │       ├── README.md
│       │       └── multiconf.make
│       ├── xxhash.c
│       └── xxhash.h
├── modules/
│   ├── Makefile
│   ├── common.mk
│   ├── redisbloom/
│   │   └── Makefile
│   ├── redisearch/
│   │   └── Makefile
│   ├── redisjson/
│   │   └── Makefile
│   ├── redistimeseries/
│   │   └── Makefile
│   └── vector-sets/
│       ├── .gitignore
│       ├── Makefile
│       ├── README.md
│       ├── commands.json
│       ├── examples/
│       │   ├── cli-tool/
│       │   │   ├── .gitignore
│       │   │   ├── README.md
│       │   │   └── cli.py
│       │   ├── glove-100/
│       │   │   ├── README
│       │   │   ├── insert.py
│       │   │   └── recall.py
│       │   └── movies/
│       │       ├── .gitignore
│       │       ├── README
│       │       └── insert.py
│       ├── expr.c
│       ├── fastjson.c
│       ├── fastjson_test.c
│       ├── hnsw.c
│       ├── hnsw.h
│       ├── mixer.h
│       ├── test.py
│       ├── tests/
│       │   ├── basic_commands.py
│       │   ├── basic_similarity.py
│       │   ├── bin_vectorization.py
│       │   ├── concurrent_vadd_cas_del_vsim.py
│       │   ├── concurrent_vsim_and_del.py
│       │   ├── debug_digest.py
│       │   ├── deletion.py
│       │   ├── dimension_validation.py
│       │   ├── epsilon.py
│       │   ├── evict_empty.py
│       │   ├── filter_expr.py
│       │   ├── filter_int.py
│       │   ├── large_scale.py
│       │   ├── memory_usage.py
│       │   ├── node_update.py
│       │   ├── persistence.py
│       │   ├── q8_similarity.py
│       │   ├── q8_vectorization.py
│       │   ├── reduce.py
│       │   ├── replication.py
│       │   ├── threading_config.py
│       │   ├── vadd_cas.py
│       │   ├── vemb.py
│       │   ├── vismember.py
│       │   ├── vrand-ping-pong.py
│       │   ├── vrandmember.py
│       │   ├── vrange.py
│       │   ├── vsim_duplicate_filter.py
│       │   ├── vsim_filter_error_leak.py
│       │   ├── vsim_limit_efsearch.py
│       │   └── with.py
│       ├── vset.c
│       ├── vset_config.c
│       ├── vset_config.h
│       └── w2v.c
├── redis-full.conf
├── redis.conf
├── runtest
├── runtest-cluster
├── runtest-moduleapi
├── runtest-sentinel
├── sentinel.conf
├── src/
│   ├── .gitignore
│   ├── Makefile
│   ├── acl.c
│   ├── adlist.c
│   ├── adlist.h
│   ├── ae.c
│   ├── ae.h
│   ├── ae_epoll.c
│   ├── ae_evport.c
│   ├── ae_kqueue.c
│   ├── ae_select.c
│   ├── anet.c
│   ├── anet.h
│   ├── aof.c
│   ├── asciilogo.h
│   ├── atomicvar.h
│   ├── bio.c
│   ├── bio.h
│   ├── bitops.c
│   ├── blocked.c
│   ├── call_reply.c
│   ├── call_reply.h
│   ├── childinfo.c
│   ├── chk.c
│   ├── chk.h
│   ├── cli_commands.c
│   ├── cli_commands.h
│   ├── cli_common.c
│   ├── cli_common.h
│   ├── cluster.c
│   ├── cluster.h
│   ├── cluster_asm.c
│   ├── cluster_asm.h
│   ├── cluster_legacy.c
│   ├── cluster_legacy.h
│   ├── cluster_slot_stats.c
│   ├── cluster_slot_stats.h
│   ├── commands/
│   │   ├── README.md
│   │   ├── acl-cat.json
│   │   ├── acl-deluser.json
│   │   ├── acl-dryrun.json
│   │   ├── acl-genpass.json
│   │   ├── acl-getuser.json
│   │   ├── acl-help.json
│   │   ├── acl-list.json
│   │   ├── acl-load.json
│   │   ├── acl-log.json
│   │   ├── acl-save.json
│   │   ├── acl-setuser.json
│   │   ├── acl-users.json
│   │   ├── acl-whoami.json
│   │   ├── acl.json
│   │   ├── append.json
│   │   ├── asking.json
│   │   ├── auth.json
│   │   ├── bgrewriteaof.json
│   │   ├── bgsave.json
│   │   ├── bitcount.json
│   │   ├── bitfield.json
│   │   ├── bitfield_ro.json
│   │   ├── bitop.json
│   │   ├── bitpos.json
│   │   ├── blmove.json
│   │   ├── blmpop.json
│   │   ├── blpop.json
│   │   ├── brpop.json
│   │   ├── brpoplpush.json
│   │   ├── bzmpop.json
│   │   ├── bzpopmax.json
│   │   ├── bzpopmin.json
│   │   ├── client-caching.json
│   │   ├── client-getname.json
│   │   ├── client-getredir.json
│   │   ├── client-help.json
│   │   ├── client-id.json
│   │   ├── client-info.json
│   │   ├── client-kill.json
│   │   ├── client-list.json
│   │   ├── client-no-evict.json
│   │   ├── client-no-touch.json
│   │   ├── client-pause.json
│   │   ├── client-reply.json
│   │   ├── client-setinfo.json
│   │   ├── client-setname.json
│   │   ├── client-tracking.json
│   │   ├── client-trackinginfo.json
│   │   ├── client-unblock.json
│   │   ├── client-unpause.json
│   │   ├── client.json
│   │   ├── cluster-addslots.json
│   │   ├── cluster-addslotsrange.json
│   │   ├── cluster-bumpepoch.json
│   │   ├── cluster-count-failure-reports.json
│   │   ├── cluster-countkeysinslot.json
│   │   ├── cluster-delslots.json
│   │   ├── cluster-delslotsrange.json
│   │   ├── cluster-failover.json
│   │   ├── cluster-flushslots.json
│   │   ├── cluster-forget.json
│   │   ├── cluster-getkeysinslot.json
│   │   ├── cluster-help.json
│   │   ├── cluster-info.json
│   │   ├── cluster-keyslot.json
│   │   ├── cluster-links.json
│   │   ├── cluster-meet.json
│   │   ├── cluster-migration.json
│   │   ├── cluster-myid.json
│   │   ├── cluster-myshardid.json
│   │   ├── cluster-nodes.json
│   │   ├── cluster-replicas.json
│   │   ├── cluster-replicate.json
│   │   ├── cluster-reset.json
│   │   ├── cluster-saveconfig.json
│   │   ├── cluster-set-config-epoch.json
│   │   ├── cluster-setslot.json
│   │   ├── cluster-shards.json
│   │   ├── cluster-slaves.json
│   │   ├── cluster-slot-stats.json
│   │   ├── cluster-slots.json
│   │   ├── cluster-syncslots.json
│   │   ├── cluster.json
│   │   ├── command-count.json
│   │   ├── command-docs.json
│   │   ├── command-getkeys.json
│   │   ├── command-getkeysandflags.json
│   │   ├── command-help.json
│   │   ├── command-info.json
│   │   ├── command-list.json
│   │   ├── command.json
│   │   ├── config-get.json
│   │   ├── config-help.json
│   │   ├── config-resetstat.json
│   │   ├── config-rewrite.json
│   │   ├── config-set.json
│   │   ├── config.json
│   │   ├── copy.json
│   │   ├── dbsize.json
│   │   ├── debug.json
│   │   ├── decr.json
│   │   ├── decrby.json
│   │   ├── del.json
│   │   ├── delex.json
│   │   ├── digest.json
│   │   ├── discard.json
│   │   ├── dump.json
│   │   ├── echo.json
│   │   ├── eval.json
│   │   ├── eval_ro.json
│   │   ├── evalsha.json
│   │   ├── evalsha_ro.json
│   │   ├── exec.json
│   │   ├── exists.json
│   │   ├── expire.json
│   │   ├── expireat.json
│   │   ├── expiretime.json
│   │   ├── failover.json
│   │   ├── fcall.json
│   │   ├── fcall_ro.json
│   │   ├── flushall.json
│   │   ├── flushdb.json
│   │   ├── function-delete.json
│   │   ├── function-dump.json
│   │   ├── function-flush.json
│   │   ├── function-help.json
│   │   ├── function-kill.json
│   │   ├── function-list.json
│   │   ├── function-load.json
│   │   ├── function-restore.json
│   │   ├── function-stats.json
│   │   ├── function.json
│   │   ├── gcra.json
│   │   ├── gcrasetvalue.json
│   │   ├── geoadd.json
│   │   ├── geodist.json
│   │   ├── geohash.json
│   │   ├── geopos.json
│   │   ├── georadius.json
│   │   ├── georadius_ro.json
│   │   ├── georadiusbymember.json
│   │   ├── georadiusbymember_ro.json
│   │   ├── geosearch.json
│   │   ├── geosearchstore.json
│   │   ├── get.json
│   │   ├── getbit.json
│   │   ├── getdel.json
│   │   ├── getex.json
│   │   ├── getrange.json
│   │   ├── getset.json
│   │   ├── hdel.json
│   │   ├── hello.json
│   │   ├── hexists.json
│   │   ├── hexpire.json
│   │   ├── hexpireat.json
│   │   ├── hexpiretime.json
│   │   ├── hget.json
│   │   ├── hgetall.json
│   │   ├── hgetdel.json
│   │   ├── hgetex.json
│   │   ├── hincrby.json
│   │   ├── hincrbyfloat.json
│   │   ├── hkeys.json
│   │   ├── hlen.json
│   │   ├── hmget.json
│   │   ├── hmset.json
│   │   ├── hotkeys-get.json
│   │   ├── hotkeys-help.json
│   │   ├── hotkeys-reset.json
│   │   ├── hotkeys-start.json
│   │   ├── hotkeys-stop.json
│   │   ├── hotkeys.json
│   │   ├── hpersist.json
│   │   ├── hpexpire.json
│   │   ├── hpexpireat.json
│   │   ├── hpexpiretime.json
│   │   ├── hpttl.json
│   │   ├── hrandfield.json
│   │   ├── hscan.json
│   │   ├── hset.json
│   │   ├── hsetex.json
│   │   ├── hsetnx.json
│   │   ├── hstrlen.json
│   │   ├── httl.json
│   │   ├── hvals.json
│   │   ├── incr.json
│   │   ├── incrby.json
│   │   ├── incrbyfloat.json
│   │   ├── info.json
│   │   ├── keys.json
│   │   ├── lastsave.json
│   │   ├── latency-doctor.json
│   │   ├── latency-graph.json
│   │   ├── latency-help.json
│   │   ├── latency-histogram.json
│   │   ├── latency-history.json
│   │   ├── latency-latest.json
│   │   ├── latency-reset.json
│   │   ├── latency.json
│   │   ├── lcs.json
│   │   ├── lindex.json
│   │   ├── linsert.json
│   │   ├── llen.json
│   │   ├── lmove.json
│   │   ├── lmpop.json
│   │   ├── lolwut.json
│   │   ├── lpop.json
│   │   ├── lpos.json
│   │   ├── lpush.json
│   │   ├── lpushx.json
│   │   ├── lrange.json
│   │   ├── lrem.json
│   │   ├── lset.json
│   │   ├── ltrim.json
│   │   ├── memory-doctor.json
│   │   ├── memory-help.json
│   │   ├── memory-malloc-stats.json
│   │   ├── memory-purge.json
│   │   ├── memory-stats.json
│   │   ├── memory-usage.json
│   │   ├── memory.json
│   │   ├── mget.json
│   │   ├── migrate.json
│   │   ├── module-help.json
│   │   ├── module-list.json
│   │   ├── module-load.json
│   │   ├── module-loadex.json
│   │   ├── module-unload.json
│   │   ├── module.json
│   │   ├── monitor.json
│   │   ├── move.json
│   │   ├── mset.json
│   │   ├── msetex.json
│   │   ├── msetnx.json
│   │   ├── multi.json
│   │   ├── object-encoding.json
│   │   ├── object-freq.json
│   │   ├── object-help.json
│   │   ├── object-idletime.json
│   │   ├── object-refcount.json
│   │   ├── object.json
│   │   ├── persist.json
│   │   ├── pexpire.json
│   │   ├── pexpireat.json
│   │   ├── pexpiretime.json
│   │   ├── pfadd.json
│   │   ├── pfcount.json
│   │   ├── pfdebug.json
│   │   ├── pfmerge.json
│   │   ├── pfselftest.json
│   │   ├── ping.json
│   │   ├── psetex.json
│   │   ├── psubscribe.json
│   │   ├── psync.json
│   │   ├── pttl.json
│   │   ├── publish.json
│   │   ├── pubsub-channels.json
│   │   ├── pubsub-help.json
│   │   ├── pubsub-numpat.json
│   │   ├── pubsub-numsub.json
│   │   ├── pubsub-shardchannels.json
│   │   ├── pubsub-shardnumsub.json
│   │   ├── pubsub.json
│   │   ├── punsubscribe.json
│   │   ├── quit.json
│   │   ├── randomkey.json
│   │   ├── readonly.json
│   │   ├── readwrite.json
│   │   ├── rename.json
│   │   ├── renamenx.json
│   │   ├── replconf.json
│   │   ├── replicaof.json
│   │   ├── reset.json
│   │   ├── restore-asking.json
│   │   ├── restore.json
│   │   ├── role.json
│   │   ├── rpop.json
│   │   ├── rpoplpush.json
│   │   ├── rpush.json
│   │   ├── rpushx.json
│   │   ├── sadd.json
│   │   ├── save.json
│   │   ├── scan.json
│   │   ├── scard.json
│   │   ├── script-debug.json
│   │   ├── script-exists.json
│   │   ├── script-flush.json
│   │   ├── script-help.json
│   │   ├── script-kill.json
│   │   ├── script-load.json
│   │   ├── script.json
│   │   ├── sdiff.json
│   │   ├── sdiffstore.json
│   │   ├── select.json
│   │   ├── sentinel-ckquorum.json
│   │   ├── sentinel-config.json
│   │   ├── sentinel-debug.json
│   │   ├── sentinel-failover.json
│   │   ├── sentinel-flushconfig.json
│   │   ├── sentinel-get-master-addr-by-name.json
│   │   ├── sentinel-help.json
│   │   ├── sentinel-info-cache.json
│   │   ├── sentinel-is-master-down-by-addr.json
│   │   ├── sentinel-master.json
│   │   ├── sentinel-masters.json
│   │   ├── sentinel-monitor.json
│   │   ├── sentinel-myid.json
│   │   ├── sentinel-pending-scripts.json
│   │   ├── sentinel-remove.json
│   │   ├── sentinel-replicas.json
│   │   ├── sentinel-reset.json
│   │   ├── sentinel-sentinels.json
│   │   ├── sentinel-set.json
│   │   ├── sentinel-simulate-failure.json
│   │   ├── sentinel-slaves.json
│   │   ├── sentinel.json
│   │   ├── set.json
│   │   ├── setbit.json
│   │   ├── setex.json
│   │   ├── setnx.json
│   │   ├── setrange.json
│   │   ├── sflush.json
│   │   ├── shutdown.json
│   │   ├── sinter.json
│   │   ├── sintercard.json
│   │   ├── sinterstore.json
│   │   ├── sismember.json
│   │   ├── slaveof.json
│   │   ├── slowlog-get.json
│   │   ├── slowlog-help.json
│   │   ├── slowlog-len.json
│   │   ├── slowlog-reset.json
│   │   ├── slowlog.json
│   │   ├── smembers.json
│   │   ├── smismember.json
│   │   ├── smove.json
│   │   ├── sort.json
│   │   ├── sort_ro.json
│   │   ├── spop.json
│   │   ├── spublish.json
│   │   ├── srandmember.json
│   │   ├── srem.json
│   │   ├── sscan.json
│   │   ├── ssubscribe.json
│   │   ├── strlen.json
│   │   ├── subscribe.json
│   │   ├── substr.json
│   │   ├── sunion.json
│   │   ├── sunionstore.json
│   │   ├── sunsubscribe.json
│   │   ├── swapdb.json
│   │   ├── sync.json
│   │   ├── time.json
│   │   ├── touch.json
│   │   ├── trimslots.json
│   │   ├── ttl.json
│   │   ├── type.json
│   │   ├── unlink.json
│   │   ├── unsubscribe.json
│   │   ├── unwatch.json
│   │   ├── wait.json
│   │   ├── waitaof.json
│   │   ├── watch.json
│   │   ├── xack.json
│   │   ├── xackdel.json
│   │   ├── xadd.json
│   │   ├── xautoclaim.json
│   │   ├── xcfgset.json
│   │   ├── xclaim.json
│   │   ├── xdel.json
│   │   ├── xdelex.json
│   │   ├── xgroup-create.json
│   │   ├── xgroup-createconsumer.json
│   │   ├── xgroup-delconsumer.json
│   │   ├── xgroup-destroy.json
│   │   ├── xgroup-help.json
│   │   ├── xgroup-setid.json
│   │   ├── xgroup.json
│   │   ├── xidmprecord.json
│   │   ├── xinfo-consumers.json
│   │   ├── xinfo-groups.json
│   │   ├── xinfo-help.json
│   │   ├── xinfo-stream.json
│   │   ├── xinfo.json
│   │   ├── xlen.json
│   │   ├── xnack.json
│   │   ├── xpending.json
│   │   ├── xrange.json
│   │   ├── xread.json
│   │   ├── xreadgroup.json
│   │   ├── xrevrange.json
│   │   ├── xsetid.json
│   │   ├── xtrim.json
│   │   ├── zadd.json
│   │   ├── zcard.json
│   │   ├── zcount.json
│   │   ├── zdiff.json
│   │   ├── zdiffstore.json
│   │   ├── zincrby.json
│   │   ├── zinter.json
│   │   ├── zintercard.json
│   │   ├── zinterstore.json
│   │   ├── zlexcount.json
│   │   ├── zmpop.json
│   │   ├── zmscore.json
│   │   ├── zpopmax.json
│   │   ├── zpopmin.json
│   │   ├── zrandmember.json
│   │   ├── zrange.json
│   │   ├── zrangebylex.json
│   │   ├── zrangebyscore.json
│   │   ├── zrangestore.json
│   │   ├── zrank.json
│   │   ├── zrem.json
│   │   ├── zremrangebylex.json
│   │   ├── zremrangebyrank.json
│   │   ├── zremrangebyscore.json
│   │   ├── zrevrange.json
│   │   ├── zrevrangebylex.json
│   │   ├── zrevrangebyscore.json
│   │   ├── zrevrank.json
│   │   ├── zscan.json
│   │   ├── zscore.json
│   │   ├── zunion.json
│   │   └── zunionstore.json
│   ├── commands.c
│   ├── commands.def
│   ├── commands.h
│   ├── config.c
│   ├── config.h
│   ├── connection.c
│   ├── connection.h
│   ├── connhelpers.h
│   ├── crc16.c
│   ├── crc16_slottable.h
│   ├── crc64.c
│   ├── crc64.h
│   ├── crccombine.c
│   ├── crccombine.h
│   ├── crcspeed.c
│   ├── crcspeed.h
│   ├── db.c
│   ├── debug.c
│   ├── debugmacro.h
│   ├── defrag.c
│   ├── dict.c
│   ├── dict.h
│   ├── ebuckets.c
│   ├── ebuckets.h
│   ├── endianconv.c
│   ├── endianconv.h
│   ├── entry.c
│   ├── entry.h
│   ├── estore.c
│   ├── estore.h
│   ├── eval.c
│   ├── eventnotifier.c
│   ├── eventnotifier.h
│   ├── evict.c
│   ├── expire.c
│   ├── fast_float_strtod.c
│   ├── fast_float_strtod.h
│   ├── fmacros.h
│   ├── fmtargs.h
│   ├── function_lua.c
│   ├── functions.c
│   ├── functions.h
│   ├── fwtree.c
│   ├── fwtree.h
│   ├── gcra.c
│   ├── geo.c
│   ├── geo.h
│   ├── geohash.c
│   ├── geohash.h
│   ├── geohash_helper.c
│   ├── geohash_helper.h
│   ├── hotkeys.c
│   ├── hyperloglog.c
│   ├── intset.c
│   ├── intset.h
│   ├── iothread.c
│   ├── keymeta.c
│   ├── keymeta.h
│   ├── kvstore.c
│   ├── kvstore.h
│   ├── latency.c
│   ├── latency.h
│   ├── lazyfree.c
│   ├── listpack.c
│   ├── listpack.h
│   ├── listpack_malloc.h
│   ├── localtime.c
│   ├── logreqres.c
│   ├── lolwut.c
│   ├── lolwut.h
│   ├── lolwut5.c
│   ├── lolwut6.c
│   ├── lolwut8.c
│   ├── lzf.h
│   ├── lzfP.h
│   ├── lzf_c.c
│   ├── lzf_d.c
│   ├── memory_prefetch.c
│   ├── memory_prefetch.h
│   ├── memtest.c
│   ├── mkreleasehdr.sh
│   ├── module.c
│   ├── modules/
│   │   ├── .gitignore
│   │   ├── Makefile
│   │   ├── helloacl.c
│   │   ├── helloblock.c
│   │   ├── hellocluster.c
│   │   ├── hellodict.c
│   │   ├── hellohook.c
│   │   ├── hellotimer.c
│   │   ├── hellotype.c
│   │   └── helloworld.c
│   ├── monotonic.c
│   ├── monotonic.h
│   ├── mstr.c
│   ├── mstr.h
│   ├── mt19937-64.c
│   ├── mt19937-64.h
│   ├── multi.c
│   ├── networking.c
│   ├── notify.c
│   ├── object.c
│   ├── object.h
│   ├── pqsort.c
│   ├── pqsort.h
│   ├── pubsub.c
│   ├── quicklist.c
│   ├── quicklist.h
│   ├── rand.c
│   ├── rand.h
│   ├── rax.c
│   ├── rax.h
│   ├── rax_malloc.h
│   ├── rdb.c
│   ├── rdb.h
│   ├── redis-benchmark.c
│   ├── redis-check-aof.c
│   ├── redis-check-rdb.c
│   ├── redis-cli.c
│   ├── redis-trib.rb
│   ├── redisassert.c
│   ├── redisassert.h
│   ├── redismodule.h
│   ├── release.c
│   ├── replication.c
│   ├── resp_parser.c
│   ├── resp_parser.h
│   ├── rio.c
│   ├── rio.h
│   ├── script.c
│   ├── script.h
│   ├── script_lua.c
│   ├── script_lua.h
│   ├── sds.c
│   ├── sds.h
│   ├── sdsalloc.h
│   ├── sentinel.c
│   ├── server.c
│   ├── server.h
│   ├── setcpuaffinity.c
│   ├── setproctitle.c
│   ├── sha1.c
│   ├── sha1.h
│   ├── sha256.c
│   ├── sha256.h
│   ├── siphash.c
│   ├── slowlog.c
│   ├── slowlog.h
│   ├── socket.c
│   ├── solarisfixes.h
│   ├── sort.c
│   ├── sparkline.c
│   ├── sparkline.h
│   ├── stream.h
│   ├── strl.c
│   ├── syncio.c
│   ├── syscheck.c
│   ├── syscheck.h
│   ├── t_hash.c
│   ├── t_list.c
│   ├── t_set.c
│   ├── t_stream.c
│   ├── t_string.c
│   ├── t_zset.c
│   ├── testhelp.h
│   ├── threads_mngr.c
│   ├── threads_mngr.h
│   ├── timeout.c
│   ├── tls.c
│   ├── tracking.c
│   ├── tsan.sup
│   ├── unix.c
│   ├── util.c
│   ├── util.h
│   ├── valgrind.sup
│   ├── vector.c
│   ├── vector.h
│   ├── version.h
│   ├── ziplist.c
│   ├── ziplist.h
│   ├── zipmap.c
│   ├── zipmap.h
│   ├── zmalloc.c
│   └── zmalloc.h
├── tests/
│   ├── README.md
│   ├── assets/
│   │   ├── corrupt_empty_keys.rdb
│   │   ├── corrupt_ziplist.rdb
│   │   ├── default.conf
│   │   ├── encodings.rdb
│   │   ├── hash-ziplist.rdb
│   │   ├── hash-zipmap.rdb
│   │   ├── list-quicklist.rdb
│   │   ├── minimal.conf
│   │   ├── nodefaultuser.acl
│   │   ├── rdb-preamble.aof
│   │   ├── scriptbackup.rdb
│   │   ├── test_cli_hint_suite.txt
│   │   ├── user.acl
│   │   ├── userwithselectors.acl
│   │   └── zset-ziplist.rdb
│   ├── cluster/
│   │   ├── cluster.tcl
│   │   ├── run.tcl
│   │   ├── tests/
│   │   │   ├── 00-base.tcl
│   │   │   ├── 01-faildet.tcl
│   │   │   ├── 02-failover.tcl
│   │   │   ├── 03-failover-loop.tcl
│   │   │   ├── 04-resharding.tcl
│   │   │   ├── 05-slave-selection.tcl
│   │   │   ├── 06-slave-stop-cond.tcl
│   │   │   ├── 07-replica-migration.tcl
│   │   │   ├── 08-update-msg.tcl
│   │   │   ├── 09-pubsub.tcl
│   │   │   ├── 10-manual-failover.tcl
│   │   │   ├── 11-manual-takeover.tcl
│   │   │   ├── 12-replica-migration-2.tcl
│   │   │   ├── 12.1-replica-migration-3.tcl
│   │   │   ├── 13-no-failover-option.tcl
│   │   │   ├── 14-consistency-check.tcl
│   │   │   ├── 15-cluster-slots.tcl
│   │   │   ├── 16-transactions-on-replica.tcl
│   │   │   ├── 17-diskless-load-swapdb.tcl
│   │   │   ├── 18-info.tcl
│   │   │   ├── 19-cluster-nodes-slots.tcl
│   │   │   ├── 20-half-migrated-slot.tcl
│   │   │   ├── 21-many-slot-migration.tcl
│   │   │   ├── 22-replica-in-sync.tcl
│   │   │   ├── 25-pubsubshard-slot-migration.tcl
│   │   │   ├── 26-pubsubshard.tcl
│   │   │   ├── 28-cluster-shards.tcl
│   │   │   ├── 29-slot-migration-response.tcl
│   │   │   ├── helpers/
│   │   │   │   └── onlydots.tcl
│   │   │   └── includes/
│   │   │       ├── init-tests.tcl
│   │   │       └── utils.tcl
│   │   └── tmp/
│   │       └── .gitignore
│   ├── helpers/
│   │   ├── bg_block_op.tcl
│   │   ├── bg_complex_data.tcl
│   │   ├── fake_redis_node.tcl
│   │   └── gen_write_load.tcl
│   ├── instances.tcl
│   ├── integration/
│   │   ├── aof-multi-part.tcl
│   │   ├── aof-race.tcl
│   │   ├── aof.tcl
│   │   ├── block-repl.tcl
│   │   ├── convert-ziplist-hash-on-load.tcl
│   │   ├── convert-ziplist-zset-on-load.tcl
│   │   ├── convert-zipmap-hash-on-load.tcl
│   │   ├── corrupt-dump-fuzzer.tcl
│   │   ├── corrupt-dump.tcl
│   │   ├── dismiss-mem.tcl
│   │   ├── failover.tcl
│   │   ├── logging.tcl
│   │   ├── psync2-master-restart.tcl
│   │   ├── psync2-pingoff.tcl
│   │   ├── psync2-reg.tcl
│   │   ├── psync2.tcl
│   │   ├── rdb.tcl
│   │   ├── redis-benchmark.tcl
│   │   ├── redis-cli.tcl
│   │   ├── replication-2.tcl
│   │   ├── replication-3.tcl
│   │   ├── replication-4.tcl
│   │   ├── replication-buffer.tcl
│   │   ├── replication-iothreads.tcl
│   │   ├── replication-psync.tcl
│   │   ├── replication-rdbchannel.tcl
│   │   ├── replication.tcl
│   │   └── shutdown.tcl
│   ├── modules/
│   │   ├── Makefile
│   │   ├── aclcheck.c
│   │   ├── atomicslotmigration.c
│   │   ├── auth.c
│   │   ├── basics.c
│   │   ├── blockedclient.c
│   │   ├── blockonbackground.c
│   │   ├── blockonkeys.c
│   │   ├── cmdintrospection.c
│   │   ├── commandfilter.c
│   │   ├── configaccess.c
│   │   ├── crash.c
│   │   ├── datatype.c
│   │   ├── datatype2.c
│   │   ├── defragtest.c
│   │   ├── eventloop.c
│   │   ├── fork.c
│   │   ├── getchannels.c
│   │   ├── getkeys.c
│   │   ├── hash.c
│   │   ├── hooks.c
│   │   ├── infotest.c
│   │   ├── internalsecret.c
│   │   ├── keymeta_notify.c
│   │   ├── keyspace_events.c
│   │   ├── keyspecs.c
│   │   ├── list.c
│   │   ├── mallocsize.c
│   │   ├── misc.c
│   │   ├── moduleauthtwo.c
│   │   ├── moduleconfigs.c
│   │   ├── moduleconfigstwo.c
│   │   ├── postnotifications.c
│   │   ├── propagate.c
│   │   ├── publish.c
│   │   ├── rdbloadsave.c
│   │   ├── reply.c
│   │   ├── scan.c
│   │   ├── stream.c
│   │   ├── subcommands.c
│   │   ├── test_keymeta.c
│   │   ├── test_lazyfree.c
│   │   ├── testrdb.c
│   │   ├── timer.c
│   │   ├── usercall.c
│   │   └── zset.c
│   ├── sentinel/
│   │   ├── run.tcl
│   │   ├── tests/
│   │   │   ├── 00-base.tcl
│   │   │   ├── 01-conf-update.tcl
│   │   │   ├── 02-slaves-reconf.tcl
│   │   │   ├── 03-runtime-reconf.tcl
│   │   │   ├── 04-slave-selection.tcl
│   │   │   ├── 05-manual.tcl
│   │   │   ├── 06-ckquorum.tcl
│   │   │   ├── 07-down-conditions.tcl
│   │   │   ├── 08-hostname-conf.tcl
│   │   │   ├── 09-acl-support.tcl
│   │   │   ├── 10-replica-priority.tcl
│   │   │   ├── 11-port-0.tcl
│   │   │   ├── 12-master-reboot.tcl
│   │   │   ├── 13-info-command.tcl
│   │   │   ├── 14-debug-command.tcl
│   │   │   ├── 15-config-set-config-get.tcl
│   │   │   ├── helpers/
│   │   │   │   └── check_leaked_fds.tcl
│   │   │   └── includes/
│   │   │       ├── init-tests.tcl
│   │   │       ├── sentinel.conf
│   │   │       ├── start-init-tests.tcl
│   │   │       └── utils.tcl
│   │   └── tmp/
│   │       └── .gitignore
│   ├── support/
│   │   ├── aofmanifest.tcl
│   │   ├── benchmark.tcl
│   │   ├── cli.tcl
│   │   ├── cluster.tcl
│   │   ├── cluster_util.tcl
│   │   ├── redis.tcl
│   │   ├── response_transformers.tcl
│   │   ├── server.tcl
│   │   ├── test.tcl
│   │   ├── tmpfile.tcl
│   │   └── util.tcl
│   ├── test_helper.tcl
│   ├── unit/
│   │   ├── acl-v2.tcl
│   │   ├── acl.tcl
│   │   ├── aofrw.tcl
│   │   ├── auth.tcl
│   │   ├── bitfield.tcl
│   │   ├── bitops.tcl
│   │   ├── client-eviction.tcl
│   │   ├── cluster/
│   │   │   ├── announced-endpoints.tcl
│   │   │   ├── atomic-slot-migration.tcl
│   │   │   ├── cli.tcl
│   │   │   ├── cluster-response-tls.tcl
│   │   │   ├── failure-marking.tcl
│   │   │   ├── hostnames.tcl
│   │   │   ├── human-announced-nodename.tcl
│   │   │   ├── internal-secret.tcl
│   │   │   ├── links.tcl
│   │   │   ├── misc.tcl
│   │   │   ├── multi-slot-operations.tcl
│   │   │   ├── scripting.tcl
│   │   │   ├── sharded-pubsub.tcl
│   │   │   ├── slot-ownership.tcl
│   │   │   └── slot-stats.tcl
│   │   ├── dump.tcl
│   │   ├── expire.tcl
│   │   ├── functions.tcl
│   │   ├── gcra.tcl
│   │   ├── geo.tcl
│   │   ├── hotkeys.tcl
│   │   ├── hyperloglog.tcl
│   │   ├── info-command.tcl
│   │   ├── info-keysizes.tcl
│   │   ├── info.tcl
│   │   ├── introspection-2.tcl
│   │   ├── introspection.tcl
│   │   ├── keyspace.tcl
│   │   ├── latency-monitor.tcl
│   │   ├── lazyfree.tcl
│   │   ├── limits.tcl
│   │   ├── maxmemory.tcl
│   │   ├── memefficiency.tcl
│   │   ├── moduleapi/
│   │   │   ├── aclcheck.tcl
│   │   │   ├── async_rm_call.tcl
│   │   │   ├── auth.tcl
│   │   │   ├── basics.tcl
│   │   │   ├── blockedclient.tcl
│   │   │   ├── blockonbackground.tcl
│   │   │   ├── blockonkeys.tcl
│   │   │   ├── cluster.tcl
│   │   │   ├── cmdintrospection.tcl
│   │   │   ├── commandfilter.tcl
│   │   │   ├── configaccess.tcl
│   │   │   ├── crash.tcl
│   │   │   ├── datatype.tcl
│   │   │   ├── datatype2.tcl
│   │   │   ├── defrag.tcl
│   │   │   ├── eventloop.tcl
│   │   │   ├── fork.tcl
│   │   │   ├── getchannels.tcl
│   │   │   ├── getkeys.tcl
│   │   │   ├── hash.tcl
│   │   │   ├── hooks.tcl
│   │   │   ├── infotest.tcl
│   │   │   ├── infra.tcl
│   │   │   ├── internalsecret.tcl
│   │   │   ├── keymeta.tcl
│   │   │   ├── keyspace_events.tcl
│   │   │   ├── keyspecs.tcl
│   │   │   ├── ksn_notify_side_effect.tcl
│   │   │   ├── list.tcl
│   │   │   ├── mallocsize.tcl
│   │   │   ├── misc.tcl
│   │   │   ├── moduleauth.tcl
│   │   │   ├── moduleconfigs.tcl
│   │   │   ├── postnotifications.tcl
│   │   │   ├── propagate.tcl
│   │   │   ├── publish.tcl
│   │   │   ├── rdbloadsave.tcl
│   │   │   ├── reply.tcl
│   │   │   ├── scan.tcl
│   │   │   ├── stream.tcl
│   │   │   ├── subcommands.tcl
│   │   │   ├── test_lazyfree.tcl
│   │   │   ├── testrdb.tcl
│   │   │   ├── timer.tcl
│   │   │   ├── usercall.tcl
│   │   │   └── zset.tcl
│   │   ├── multi.tcl
│   │   ├── networking.tcl
│   │   ├── obuf-limits.tcl
│   │   ├── oom-score-adj.tcl
│   │   ├── other.tcl
│   │   ├── pause.tcl
│   │   ├── printver.tcl
│   │   ├── protocol.tcl
│   │   ├── pubsub.tcl
│   │   ├── pubsubshard.tcl
│   │   ├── querybuf.tcl
│   │   ├── quit.tcl
│   │   ├── replybufsize.tcl
│   │   ├── scan.tcl
│   │   ├── scripting.tcl
│   │   ├── shutdown.tcl
│   │   ├── slowlog.tcl
│   │   ├── sort.tcl
│   │   ├── tls.tcl
│   │   ├── tracking.tcl
│   │   ├── type/
│   │   │   ├── hash-field-expire.tcl
│   │   │   ├── hash.tcl
│   │   │   ├── incr.tcl
│   │   │   ├── list-2.tcl
│   │   │   ├── list-3.tcl
│   │   │   ├── list.tcl
│   │   │   ├── set.tcl
│   │   │   ├── stream-cgroups.tcl
│   │   │   ├── stream.tcl
│   │   │   ├── string.tcl
│   │   │   └── zset.tcl
│   │   ├── violations.tcl
│   │   └── wait.tcl
│   └── vectorset/
│       └── vectorset.tcl
└── utils/
    ├── build-static-symbols.tcl
    ├── cluster_fail_time.tcl
    ├── corrupt_rdb.c
    ├── create-cluster/
    │   ├── .gitignore
    │   ├── README
    │   └── create-cluster
    ├── gen-test-certs.sh
    ├── generate-command-code.py
    ├── generate-commands-json.py
    ├── generate-fmtargs.py
    ├── generate-module-api-doc.rb
    ├── graphs/
    │   └── commits-over-time/
    │       ├── README.md
    │       └── genhtml.tcl
    ├── hyperloglog/
    │   ├── .gitignore
    │   ├── hll-err.rb
    │   └── hll-gnuplot-graph.rb
    ├── install_server.sh
    ├── lru/
    │   ├── README
    │   ├── lfu-simulation.c
    │   └── test-lru.rb
    ├── redis-copy.rb
    ├── redis-sha1.rb
    ├── redis_init_script
    ├── redis_init_script.tpl
    ├── releasetools/
    │   ├── 01_create_tarball.sh
    │   ├── 02_upload_tarball.sh
    │   ├── 03_test_release.sh
    │   ├── 04_release_hash.sh
    │   └── changelog.tcl
    ├── reply_schema_linter.js
    ├── req-res-log-validator.py
    ├── req-res-validator/
    │   └── requirements.txt
    ├── speed-regression.tcl
    ├── srandmember/
    │   ├── README.md
    │   ├── showdist.rb
    │   └── showfreq.rb
    ├── systemd-redis_multiple_servers@.service
    ├── systemd-redis_server.service
    ├── tracking_collisions.c
    └── whatisdoing.sh

SYMBOL INDEX (12077 symbols across 697 files)

FILE: deps/fpconv/fpconv_dtoa.c
  function get_dbits (line 75) | static inline uint64_t get_dbits(double d) {
  function Fp (line 85) | static Fp build_fp(double d) {
  function normalize (line 103) | static void normalize(Fp *fp) {
  function get_normalized_boundaries (line 114) | static void get_normalized_boundaries(Fp *fp, Fp *lower, Fp *upper) {
  function Fp (line 137) | static Fp multiply(Fp *a, Fp *b) {
  function round_digit (line 154) | static void round_digit(char *digits,
  function generate_digits (line 167) | static int generate_digits(Fp *fp, Fp *upper, Fp *lower, char *digits, i...
  function grisu2 (line 226) | static int grisu2(double d, char *digits, int *K) {
  function emit_digits (line 249) | static int emit_digits(char *digits, int ndigits, char *dest, int K, boo...
  function filter_special (line 321) | static int filter_special(double fp, char *dest) {
  function fpconv_dtoa (line 349) | int fpconv_dtoa(double d, char dest[24]) {

FILE: deps/fpconv/fpconv_powers.h
  type Fp (line 49) | typedef struct Fp {
  function Fp (line 109) | static Fp find_cachedpow10(int exp, int* k)

FILE: deps/hdr_histogram/hdr_atomic.h
  function hdr_atomic_store_pointer (line 23) | static void hdr_atomic_store_pointer(void** pointer, void* value)
  function hdr_atomic_load_64 (line 29) | static int64_t __inline hdr_atomic_load_64(int64_t* field)
  function hdr_atomic_store_64 (line 35) | static void __inline hdr_atomic_store_64(int64_t* field, int64_t value)
  function hdr_atomic_exchange_64 (line 41) | static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, ...
  function hdr_atomic_add_fetch_64 (line 59) | static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field,...
  function hdr_atomic_compare_exchange_64 (line 77) | static bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* fi...
  function hdr_atomic_store_pointer (line 104) | static inline void hdr_atomic_store_pointer(void** pointer, void* value)
  function hdr_atomic_load_64 (line 109) | static inline int64_t hdr_atomic_load_64(int64_t* field)
  function hdr_atomic_store_64 (line 116) | static inline void hdr_atomic_store_64(int64_t* field, int64_t value)
  function hdr_atomic_exchange_64 (line 121) | static inline int64_t hdr_atomic_exchange_64(volatile int64_t* field, in...
  function hdr_atomic_add_fetch_64 (line 128) | static inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, i...
  function hdr_atomic_compare_exchange_64 (line 133) | static inline bool hdr_atomic_compare_exchange_64(volatile int64_t* fiel...

FILE: deps/hdr_histogram/hdr_histogram.c
  function normalize_index (line 34) | static int32_t normalize_index(const struct hdr_histogram* h, int32_t in...
  function counts_get_direct (line 57) | static int64_t counts_get_direct(const struct hdr_histogram* h, int32_t ...
  function counts_get_normalised (line 62) | static int64_t counts_get_normalised(const struct hdr_histogram* h, int3...
  function counts_inc_normalised (line 67) | static void counts_inc_normalised(
  function counts_inc_normalised_atomic (line 75) | static void counts_inc_normalised_atomic(
  function update_min_max (line 84) | static void update_min_max(struct hdr_histogram* h, int64_t value)
  function update_min_max_atomic (line 90) | static void update_min_max_atomic(struct hdr_histogram* h, int64_t value)
  function power (line 126) | static int64_t power(int64_t base, int64_t exp)
  function count_leading_zeros_64 (line 144) | static int32_t count_leading_zeros_64(int64_t value)
  function get_bucket_index (line 168) | static int32_t get_bucket_index(const struct hdr_histogram* h, int64_t v...
  function get_sub_bucket_index (line 174) | static int32_t get_sub_bucket_index(int64_t value, int32_t bucket_index,...
  function counts_index (line 179) | static int32_t counts_index(const struct hdr_histogram* h, int32_t bucke...
  function value_from_index (line 190) | static int64_t value_from_index(int32_t bucket_index, int32_t sub_bucket...
  function counts_index_for (line 195) | int32_t counts_index_for(const struct hdr_histogram* h, int64_t value)
  function hdr_value_at_index (line 203) | int64_t hdr_value_at_index(const struct hdr_histogram *h, int32_t index)
  function hdr_size_of_equivalent_value_range (line 217) | int64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h...
  function size_of_equivalent_value_range_given_bucket_indices (line 225) | static int64_t size_of_equivalent_value_range_given_bucket_indices(
  function lowest_equivalent_value (line 234) | static int64_t lowest_equivalent_value(const struct hdr_histogram* h, in...
  function lowest_equivalent_value_given_bucket_indices (line 241) | static int64_t lowest_equivalent_value_given_bucket_indices(
  function hdr_next_non_equivalent_value (line 249) | int64_t hdr_next_non_equivalent_value(const struct hdr_histogram *h, int...
  function highest_equivalent_value (line 254) | static int64_t highest_equivalent_value(const struct hdr_histogram* h, i...
  function hdr_median_equivalent_value (line 259) | int64_t hdr_median_equivalent_value(const struct hdr_histogram *h, int64...
  function non_zero_min (line 264) | static int64_t non_zero_min(const struct hdr_histogram* h)
  function hdr_reset_internal_counters (line 274) | void hdr_reset_internal_counters(struct hdr_histogram* h)
  function buckets_needed_to_cover_value (line 318) | static int32_t buckets_needed_to_cover_value(int64_t value, int32_t sub_...
  function hdr_calculate_bucket_config (line 343) | int hdr_calculate_bucket_config(
  function hdr_init_preallocated (line 389) | void hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram...
  function hdr_init (line 408) | int hdr_init(
  function hdr_close (line 445) | void hdr_close(struct hdr_histogram* h)
  function hdr_alloc (line 453) | int hdr_alloc(int64_t highest_trackable_value, int significant_figures, ...
  function hdr_reset (line 459) | void hdr_reset(struct hdr_histogram *h)
  function hdr_get_memory_size (line 467) | size_t hdr_get_memory_size(struct hdr_histogram *h)
  function hdr_record_value (line 481) | bool hdr_record_value(struct hdr_histogram* h, int64_t value)
  function hdr_record_value_atomic (line 486) | bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value)
  function hdr_record_values (line 491) | bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t c...
  function hdr_record_values_atomic (line 513) | bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, in...
  function hdr_record_corrected_value (line 535) | bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, ...
  function hdr_record_corrected_value_atomic (line 540) | bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t ...
  function hdr_record_corrected_values (line 545) | bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value,...
  function hdr_record_corrected_values_atomic (line 571) | bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t...
  function hdr_add (line 597) | int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from)
  function hdr_add_while_correcting_for_coordinated_omission (line 617) | int64_t hdr_add_while_correcting_for_coordinated_omission(
  function hdr_max (line 649) | int64_t hdr_max(const struct hdr_histogram* h)
  function hdr_min (line 659) | int64_t hdr_min(const struct hdr_histogram* h)
  function get_value_from_idx_up_to_count (line 669) | static int64_t get_value_from_idx_up_to_count(const struct hdr_histogram...
  function hdr_value_at_percentile (line 687) | int64_t hdr_value_at_percentile(const struct hdr_histogram* h, double pe...
  function hdr_value_at_percentiles (line 700) | int hdr_value_at_percentiles(const struct hdr_histogram *h, const double...
  function hdr_mean (line 734) | double hdr_mean(const struct hdr_histogram* h)
  function hdr_stddev (line 752) | double hdr_stddev(const struct hdr_histogram* h)
  function hdr_values_are_equivalent (line 772) | bool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a,...
  function hdr_lowest_equivalent_value (line 777) | int64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64...
  function hdr_count_at_value (line 782) | int64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value)
  function hdr_count_at_index (line 787) | int64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index)
  function has_buckets (line 802) | static bool has_buckets(struct hdr_iter* iter)
  function has_next (line 807) | static bool has_next(struct hdr_iter* iter)
  function move_next (line 812) | static bool move_next(struct hdr_iter* iter)
  function peek_next_value_from_index (line 837) | static int64_t peek_next_value_from_index(struct hdr_iter* iter)
  function next_value_greater_than_reporting_level_upper_bound (line 842) | static bool next_value_greater_than_reporting_level_upper_bound(
  function basic_iter_next (line 853) | static bool basic_iter_next(struct hdr_iter *iter)
  function update_iterated_values (line 865) | static void update_iterated_values(struct hdr_iter* iter, int64_t new_va...
  function all_values_iter_next (line 871) | static bool all_values_iter_next(struct hdr_iter* iter)
  function hdr_iter_init (line 883) | void hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h)
  function hdr_iter_next (line 899) | bool hdr_iter_next(struct hdr_iter* iter)
  function percentile_iter_next (line 912) | static bool percentile_iter_next(struct hdr_iter* iter)
  function hdr_iter_percentile_init (line 958) | void hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_hi...
  function format_line_string (line 972) | static void format_line_string(char* str, size_t len, int significant_fi...
  function recorded_iter_next (line 1008) | static bool recorded_iter_next(struct hdr_iter* iter)
  function hdr_iter_recorded_init (line 1024) | void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_hist...
  function iter_linear_next (line 1042) | static bool iter_linear_next(struct hdr_iter* iter)
  function hdr_iter_linear_init (line 1079) | void hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histog...
  function hdr_iter_linear_set_value_units_per_bucket (line 1091) | void hdr_iter_linear_set_value_units_per_bucket(struct hdr_iter* iter, i...
  function log_iter_next (line 1104) | static bool log_iter_next(struct hdr_iter *iter)
  function hdr_iter_log_init (line 1139) | void hdr_iter_log_init(
  function hdr_percentiles_print (line 1173) | int hdr_percentiles_print(

FILE: deps/hdr_histogram/hdr_histogram.h
  type hdr_histogram (line 17) | struct hdr_histogram
  type hdr_histogram (line 65) | struct hdr_histogram
  type hdr_histogram (line 72) | struct hdr_histogram
  type hdr_histogram (line 80) | struct hdr_histogram
  type hdr_histogram (line 92) | struct hdr_histogram
  type hdr_histogram (line 100) | struct hdr_histogram
  type hdr_histogram (line 111) | struct hdr_histogram
  type hdr_histogram (line 126) | struct hdr_histogram
  type hdr_histogram (line 139) | struct hdr_histogram
  type hdr_histogram (line 156) | struct hdr_histogram
  type hdr_histogram (line 173) | struct hdr_histogram
  type hdr_histogram (line 194) | struct hdr_histogram
  type hdr_histogram (line 207) | struct hdr_histogram
  type hdr_histogram (line 224) | struct hdr_histogram
  type hdr_histogram (line 236) | struct hdr_histogram
  type hdr_histogram (line 236) | struct hdr_histogram
  type hdr_histogram (line 249) | struct hdr_histogram
  type hdr_histogram (line 249) | struct hdr_histogram
  type hdr_histogram (line 257) | struct hdr_histogram
  type hdr_histogram (line 265) | struct hdr_histogram
  type hdr_histogram (line 273) | struct hdr_histogram
  type hdr_histogram (line 285) | struct hdr_histogram
  type hdr_histogram (line 293) | struct hdr_histogram
  type hdr_histogram (line 301) | struct hdr_histogram
  type hdr_histogram (line 313) | struct hdr_histogram
  type hdr_histogram (line 324) | struct hdr_histogram
  type hdr_histogram (line 335) | struct hdr_histogram
  type hdr_histogram (line 337) | struct hdr_histogram
  type hdr_histogram (line 339) | struct hdr_histogram
  type hdr_iter_percentiles (line 341) | struct hdr_iter_percentiles
  type hdr_iter_recorded (line 349) | struct hdr_iter_recorded
  type hdr_iter_linear (line 354) | struct hdr_iter_linear
  type hdr_iter_log (line 362) | struct hdr_iter_log
  type hdr_iter (line 378) | struct hdr_iter
  type hdr_iter (line 415) | struct hdr_iter
  type hdr_histogram (line 415) | struct hdr_histogram
  type hdr_iter (line 420) | struct hdr_iter
  type hdr_histogram (line 420) | struct hdr_histogram
  type hdr_iter (line 425) | struct hdr_iter
  type hdr_histogram (line 425) | struct hdr_histogram
  type hdr_iter (line 431) | struct hdr_iter
  type hdr_histogram (line 432) | struct hdr_histogram
  type hdr_iter (line 438) | struct hdr_iter
  type hdr_iter (line 444) | struct hdr_iter
  type hdr_histogram (line 445) | struct hdr_histogram
  type hdr_iter (line 456) | struct hdr_iter
  type format_type (line 458) | typedef enum
  type hdr_histogram (line 477) | struct hdr_histogram
  type hdr_histogram_bucket_config (line 483) | struct hdr_histogram_bucket_config
  type hdr_histogram_bucket_config (line 501) | struct hdr_histogram_bucket_config
  type hdr_histogram (line 503) | struct hdr_histogram
  type hdr_histogram_bucket_config (line 503) | struct hdr_histogram_bucket_config
  type hdr_histogram (line 505) | struct hdr_histogram
  type hdr_histogram (line 507) | struct hdr_histogram
  type hdr_histogram (line 509) | struct hdr_histogram
  type hdr_histogram (line 515) | struct hdr_histogram

FILE: deps/hdr_histogram/hdr_tests.h
  type hdr_histogram (line 12) | struct hdr_histogram
  type hdr_histogram (line 13) | struct hdr_histogram
  type hdr_histogram (line 14) | struct hdr_histogram

FILE: deps/hiredis/adapters/ae.h
  type redisAeEvents (line 38) | typedef struct redisAeEvents {
  function redisAeReadEvent (line 45) | static void redisAeReadEvent(aeEventLoop *el, int fd, void *privdata, in...
  function redisAeWriteEvent (line 52) | static void redisAeWriteEvent(aeEventLoop *el, int fd, void *privdata, i...
  function redisAeAddRead (line 59) | static void redisAeAddRead(void *privdata) {
  function redisAeDelRead (line 68) | static void redisAeDelRead(void *privdata) {
  function redisAeAddWrite (line 77) | static void redisAeAddWrite(void *privdata) {
  function redisAeDelWrite (line 86) | static void redisAeDelWrite(void *privdata) {
  function redisAeCleanup (line 95) | static void redisAeCleanup(void *privdata) {
  function redisAeAttach (line 102) | static int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) {

FILE: deps/hiredis/adapters/glib.h
  type RedisSource (line 9) | typedef struct
  function redis_source_add_read (line 16) | static void
  function redis_source_del_read (line 25) | static void
  function redis_source_add_write (line 34) | static void
  function redis_source_del_write (line 43) | static void
  function redis_source_cleanup (line 52) | static void
  function gboolean (line 71) | static gboolean
  function gboolean (line 80) | static gboolean
  function gboolean (line 87) | static gboolean
  function redis_source_finalize (line 111) | static void
  function GSource (line 122) | static GSource *

FILE: deps/hiredis/adapters/ivykis.h
  type redisIvykisEvents (line 7) | typedef struct redisIvykisEvents {
  function redisIvykisReadEvent (line 12) | static void redisIvykisReadEvent(void *arg) {
  function redisIvykisWriteEvent (line 17) | static void redisIvykisWriteEvent(void *arg) {
  function redisIvykisAddRead (line 22) | static void redisIvykisAddRead(void *privdata) {
  function redisIvykisDelRead (line 27) | static void redisIvykisDelRead(void *privdata) {
  function redisIvykisAddWrite (line 32) | static void redisIvykisAddWrite(void *privdata) {
  function redisIvykisDelWrite (line 37) | static void redisIvykisDelWrite(void *privdata) {
  function redisIvykisCleanup (line 42) | static void redisIvykisCleanup(void *privdata) {
  function redisIvykisAttach (line 49) | static int redisIvykisAttach(redisAsyncContext *ac) {

FILE: deps/hiredis/adapters/libev.h
  type redisLibevEvents (line 39) | typedef struct redisLibevEvents {
  function redisLibevReadEvent (line 47) | static void redisLibevReadEvent(EV_P_ ev_io *watcher, int revents) {
  function redisLibevWriteEvent (line 57) | static void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) {
  function redisLibevAddRead (line 67) | static void redisLibevAddRead(void *privdata) {
  function redisLibevDelRead (line 78) | static void redisLibevDelRead(void *privdata) {
  function redisLibevAddWrite (line 89) | static void redisLibevAddWrite(void *privdata) {
  function redisLibevDelWrite (line 100) | static void redisLibevDelWrite(void *privdata) {
  function redisLibevStopTimer (line 111) | static void redisLibevStopTimer(void *privdata) {
  function redisLibevCleanup (line 119) | static void redisLibevCleanup(void *privdata) {
  function redisLibevTimeout (line 127) | static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {
  function redisLibevSetTimeout (line 136) | static void redisLibevSetTimeout(void *privdata, struct timeval tv) {
  function redisLibevAttach (line 151) | static int redisLibevAttach(EV_P_ redisAsyncContext *ac) {

FILE: deps/hiredis/adapters/libevent.h
  type redisLibeventEvents (line 40) | typedef struct redisLibeventEvents {
  function redisLibeventDestroy (line 49) | static void redisLibeventDestroy(redisLibeventEvents *e) {
  function redisLibeventHandler (line 53) | static void redisLibeventHandler(evutil_socket_t fd, short event, void *...
  function redisLibeventUpdate (line 82) | static void redisLibeventUpdate(void *privdata, short flag, int isRemove) {
  function redisLibeventAddRead (line 106) | static void redisLibeventAddRead(void *privdata) {
  function redisLibeventDelRead (line 110) | static void redisLibeventDelRead(void *privdata) {
  function redisLibeventAddWrite (line 114) | static void redisLibeventAddWrite(void *privdata) {
  function redisLibeventDelWrite (line 118) | static void redisLibeventDelWrite(void *privdata) {
  function redisLibeventCleanup (line 122) | static void redisLibeventCleanup(void *privdata) {
  function redisLibeventSetTimeout (line 138) | static void redisLibeventSetTimeout(void *privdata, struct timeval tv) {
  function redisLibeventAttach (line 146) | static int redisLibeventAttach(redisAsyncContext *ac, struct event_base ...

FILE: deps/hiredis/adapters/libhv.h
  type redisLibhvEvents (line 8) | typedef struct redisLibhvEvents {
  function redisLibhvHandleEvents (line 13) | static void redisLibhvHandleEvents(hio_t* io) {
  function redisLibhvAddRead (line 25) | static void redisLibhvAddRead(void *privdata) {
  function redisLibhvDelRead (line 30) | static void redisLibhvDelRead(void *privdata) {
  function redisLibhvAddWrite (line 35) | static void redisLibhvAddWrite(void *privdata) {
  function redisLibhvDelWrite (line 40) | static void redisLibhvDelWrite(void *privdata) {
  function redisLibhvCleanup (line 45) | static void redisLibhvCleanup(void *privdata) {
  function redisLibhvTimeout (line 57) | static void redisLibhvTimeout(htimer_t* timer) {
  function redisLibhvSetTimeout (line 62) | static void redisLibhvSetTimeout(void *privdata, struct timeval tv) {
  function redisLibhvAttach (line 87) | static int redisLibhvAttach(redisAsyncContext* ac, hloop_t* loop) {

FILE: deps/hiredis/adapters/libsdevent.h
  type redisLibsdeventEvents (line 10) | typedef struct redisLibsdeventEvents {
  function redisLibsdeventDestroy (line 20) | static void redisLibsdeventDestroy(redisLibsdeventEvents *e) {
  function redisLibsdeventTimeoutHandler (line 31) | static int redisLibsdeventTimeoutHandler(sd_event_source *s, uint64_t us...
  function redisLibsdeventHandler (line 39) | static int redisLibsdeventHandler(sd_event_source *s, int fd, uint32_t e...
  function redisLibsdeventAddRead (line 66) | static void redisLibsdeventAddRead(void *userdata) {
  function redisLibsdeventDelRead (line 82) | static void redisLibsdeventDelRead(void *userdata) {
  function redisLibsdeventAddWrite (line 94) | static void redisLibsdeventAddWrite(void *userdata) {
  function redisLibsdeventDelWrite (line 110) | static void redisLibsdeventDelWrite(void *userdata) {
  function redisLibsdeventCleanup (line 122) | static void redisLibsdeventCleanup(void *userdata) {
  function redisLibsdeventSetTimeout (line 136) | static void redisLibsdeventSetTimeout(void *userdata, struct timeval tv) {
  function redisLibsdeventAttach (line 147) | static int redisLibsdeventAttach(redisAsyncContext *ac, struct sd_event ...

FILE: deps/hiredis/adapters/libuv.h
  type redisLibuvEvents (line 9) | typedef struct redisLibuvEvents {
  function redisLibuvPoll (line 17) | static void redisLibuvPoll(uv_poll_t* handle, int status, int events) {
  function redisLibuvAddRead (line 30) | static void redisLibuvAddRead(void *privdata) {
  function redisLibuvDelRead (line 43) | static void redisLibuvDelRead(void *privdata) {
  function redisLibuvAddWrite (line 56) | static void redisLibuvAddWrite(void *privdata) {
  function redisLibuvDelWrite (line 69) | static void redisLibuvDelWrite(void *privdata) {
  function on_timer_close (line 81) | static void on_timer_close(uv_handle_t *handle) {
  function on_handle_close (line 91) | static void on_handle_close(uv_handle_t *handle) {
  function redisLibuvTimeout (line 108) | static void redisLibuvTimeout(uv_timer_t *timer) {
  function redisLibuvSetTimeout (line 114) | static void redisLibuvSetTimeout(void *privdata, struct timeval tv) {
  function redisLibuvCleanup (line 130) | static void redisLibuvCleanup(void *privdata) {
  function redisLibuvAttach (line 141) | static int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) {

FILE: deps/hiredis/adapters/macosx.h
  type RedisRunLoop (line 14) | typedef struct {
  function freeRedisRunLoop (line 20) | static int freeRedisRunLoop(RedisRunLoop* redisRunLoop) {
  function redisMacOSAddRead (line 35) | static void redisMacOSAddRead(void *privdata) {
  function redisMacOSDelRead (line 40) | static void redisMacOSDelRead(void *privdata) {
  function redisMacOSAddWrite (line 45) | static void redisMacOSAddWrite(void *privdata) {
  function redisMacOSDelWrite (line 50) | static void redisMacOSDelWrite(void *privdata) {
  function redisMacOSCleanup (line 55) | static void redisMacOSCleanup(void *privdata) {
  function redisMacOSAsyncCallback (line 60) | static void redisMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCall...
  function redisMacOSAttach (line 77) | static int redisMacOSAttach(redisAsyncContext *redisAsyncCtx, CFRunLoopR...

FILE: deps/hiredis/adapters/poll.h
  type redisPollEvents (line 19) | typedef struct redisPollEvents {
  function redisPollTimevalToDouble (line 28) | static double redisPollTimevalToDouble(struct timeval *tv) {
  function redisPollGetNow (line 34) | static double redisPollGetNow(void) {
  function redisPollTick (line 52) | static int redisPollTick(redisAsyncContext *ac, double timeout) {
  function redisPollAddRead (line 129) | static void redisPollAddRead(void *data) {
  function redisPollDelRead (line 134) | static void redisPollDelRead(void *data) {
  function redisPollAddWrite (line 139) | static void redisPollAddWrite(void *data) {
  function redisPollDelWrite (line 144) | static void redisPollDelWrite(void *data) {
  function redisPollCleanup (line 149) | static void redisPollCleanup(void *data) {
  function redisPollScheduleTimer (line 159) | static void redisPollScheduleTimer(void *data, struct timeval tv)
  function redisPollAttach (line 166) | static int redisPollAttach(redisAsyncContext *ac) {

FILE: deps/hiredis/adapters/qt.h
  function class (line 37) | class RedisQtAdapter : public QObject {

FILE: deps/hiredis/adapters/redismoduleapi.h
  type redisModuleEvents (line 11) | typedef struct redisModuleEvents {
  function redisModuleReadEvent (line 20) | static inline void redisModuleReadEvent(int fd, void *privdata, int mask) {
  function redisModuleWriteEvent (line 28) | static inline void redisModuleWriteEvent(int fd, void *privdata, int mas...
  function redisModuleAddRead (line 36) | static inline void redisModuleAddRead(void *privdata) {
  function redisModuleDelRead (line 44) | static inline void redisModuleDelRead(void *privdata) {
  function redisModuleAddWrite (line 52) | static inline void redisModuleAddWrite(void *privdata) {
  function redisModuleDelWrite (line 60) | static inline void redisModuleDelWrite(void *privdata) {
  function redisModuleStopTimer (line 68) | static inline void redisModuleStopTimer(void *privdata) {
  function redisModuleCleanup (line 76) | static inline void redisModuleCleanup(void *privdata) {
  function redisModuleTimeout (line 84) | static inline void redisModuleTimeout(RedisModuleCtx *ctx, void *privdat...
  function redisModuleSetTimeout (line 92) | static inline void redisModuleSetTimeout(void *privdata, struct timeval ...
  function redisModuleCompatibilityCheck (line 103) | static inline int redisModuleCompatibilityCheck(void) {
  function redisModuleAttach (line 113) | static inline int redisModuleAttach(redisAsyncContext *ac, RedisModuleCt...

FILE: deps/hiredis/alloc.c
  function hiredisAllocFuncs (line 45) | hiredisAllocFuncs hiredisSetAllocators(hiredisAllocFuncs *override) {
  function hiredisResetAllocators (line 54) | void hiredisResetAllocators(void) {
  function hi_free (line 86) | void hi_free(void *ptr) {

FILE: deps/hiredis/alloc.h
  type hiredisAllocFuncs (line 42) | typedef struct hiredisAllocFuncs {
  function hi_free (line 78) | static inline void hi_free(void *ptr) {

FILE: deps/hiredis/async.c
  function callbackHash (line 60) | static unsigned int callbackHash(const void *key) {
  function callbackKeyCompare (line 77) | static int callbackKeyCompare(void *privdata, const void *key1, const vo...
  function callbackKeyDestructor (line 87) | static void callbackKeyDestructor(void *privdata, void *key) {
  function callbackValDestructor (line 92) | static void callbackValDestructor(void *privdata, void *val) {
  function redisAsyncContext (line 106) | static redisAsyncContext *redisAsyncInitialize(redisContext *c) {
  function __redisAsyncCopyError (line 163) | static void __redisAsyncCopyError(redisAsyncContext *ac) {
  function redisAsyncContext (line 172) | redisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *opti...
  function redisAsyncContext (line 201) | redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
  function redisAsyncContext (line 207) | redisAsyncContext *redisAsyncConnectBind(const char *ip, int port,
  function redisAsyncContext (line 215) | redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
  function redisAsyncContext (line 224) | redisAsyncContext *redisAsyncConnectUnix(const char *path) {
  function redisAsyncSetConnectCallbackImpl (line 230) | static int
  function redisAsyncSetConnectCallback (line 252) | int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCall...
  function redisAsyncSetConnectCallbackNC (line 256) | int redisAsyncSetConnectCallbackNC(redisAsyncContext *ac, redisConnectCa...
  function redisAsyncSetDisconnectCallback (line 260) | int redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconne...
  function __redisPushCallback (line 269) | static int __redisPushCallback(redisCallbackList *list, redisCallback *s...
  function __redisShiftCallback (line 291) | static int __redisShiftCallback(redisCallbackList *list, redisCallback *...
  function __redisRunCallback (line 307) | static void __redisRunCallback(redisAsyncContext *ac, redisCallback *cb,...
  function __redisRunPushCallback (line 316) | static void __redisRunPushCallback(redisAsyncContext *ac, redisReply *re...
  function __redisRunConnectCallback (line 324) | static void __redisRunConnectCallback(redisAsyncContext *ac, int status)
  function __redisRunDisconnectCallback (line 347) | static void __redisRunDisconnectCallback(redisAsyncContext *ac, int status)
  function __redisAsyncFree (line 362) | static void __redisAsyncFree(redisAsyncContext *ac) {
  function redisAsyncFree (line 415) | void redisAsyncFree(redisAsyncContext *ac) {
  function __redisAsyncDisconnect (line 427) | void __redisAsyncDisconnect(redisAsyncContext *ac) {
  function redisAsyncDisconnect (line 460) | void redisAsyncDisconnect(redisAsyncContext *ac) {
  function __redisGetSubscribeCallback (line 470) | static int __redisGetSubscribeCallback(redisAsyncContext *ac, redisReply...
  function redisIsSubscribeReply (line 549) | static int redisIsSubscribeReply(redisReply *reply) {
  function redisProcessCallbacks (line 570) | void redisProcessCallbacks(redisAsyncContext *ac) {
  function __redisAsyncHandleConnectFailure (line 664) | static void __redisAsyncHandleConnectFailure(redisAsyncContext *ac) {
  function __redisAsyncHandleConnect (line 672) | static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
  function redisAsyncRead (line 709) | void redisAsyncRead(redisAsyncContext *ac) {
  function redisAsyncHandleRead (line 724) | void redisAsyncHandleRead(redisAsyncContext *ac) {
  function redisAsyncWrite (line 741) | void redisAsyncWrite(redisAsyncContext *ac) {
  function redisAsyncHandleWrite (line 759) | void redisAsyncHandleWrite(redisAsyncContext *ac) {
  function redisAsyncHandleTimeout (line 776) | void redisAsyncHandleTimeout(redisAsyncContext *ac) {
  function __redisAsyncCommand (line 834) | static int __redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *f...
  function redisvAsyncCommand (line 970) | int redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void ...
  function redisAsyncCommand (line 985) | int redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *...
  function redisAsyncCommandArgv (line 994) | int redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, vo...
  function redisAsyncFormattedCommand (line 1006) | int redisAsyncFormattedCommand(redisAsyncContext *ac, redisCallbackFn *f...
  function redisAsyncPushFn (line 1011) | redisAsyncPushFn *redisAsyncSetPushCallback(redisAsyncContext *ac, redis...
  function redisAsyncSetTimeout (line 1017) | int redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv) {

FILE: deps/hiredis/async.h
  type redisAsyncContext (line 40) | struct redisAsyncContext
  type dict (line 41) | struct dict
  type redisAsyncContext (line 44) | struct redisAsyncContext
  type redisCallback (line 45) | typedef struct redisCallback {
  type redisCallbackList (line 54) | typedef struct redisCallbackList {
  type redisAsyncContext (line 59) | struct redisAsyncContext
  type redisAsyncContext (line 60) | struct redisAsyncContext
  type redisAsyncContext (line 61) | struct redisAsyncContext
  type redisAsyncContext (line 65) | typedef struct redisAsyncContext {
  type timeval (line 130) | struct timeval

FILE: deps/hiredis/async_private.h
  function refreshTimeout (line 56) | static inline void refreshTimeout(redisAsyncContext *ctx) {

FILE: deps/hiredis/dict.c
  function dictGenHashFunction (line 54) | static unsigned int dictGenHashFunction(const unsigned char *buf, int le...
  function _dictReset (line 66) | static void _dictReset(dict *ht) {
  function dict (line 74) | static dict *dictCreate(dictType *type, void *privDataPtr) {
  function _dictInit (line 84) | static int _dictInit(dict *ht, dictType *type, void *privDataPtr) {
  function dictExpand (line 92) | static int dictExpand(dict *ht, unsigned long size) {
  function dictAdd (line 141) | static int dictAdd(dict *ht, void *key, void *val) {
  function dictReplace (line 169) | static int dictReplace(dict *ht, void *key, void *val) {
  function dictDelete (line 194) | static int dictDelete(dict *ht, const void *key) {
  function _dictClear (line 225) | static int _dictClear(dict *ht) {
  function dictRelease (line 250) | static void dictRelease(dict *ht) {
  function dictEntry (line 255) | static dictEntry *dictFind(dict *ht, const void *key) {
  function dictInitIterator (line 270) | static void dictInitIterator(dictIterator *iter, dict *ht) {
  function dictEntry (line 277) | static dictEntry *dictNext(dictIterator *iter) {
  function _dictExpandIfNeeded (line 300) | static int _dictExpandIfNeeded(dict *ht) {
  function _dictNextPower (line 311) | static unsigned long _dictNextPower(unsigned long size) {
  function _dictKeyIndex (line 325) | static int _dictKeyIndex(dict *ht, const void *key) {

FILE: deps/hiredis/dict.h
  type dictEntry (line 45) | typedef struct dictEntry {
  type dictType (line 51) | typedef struct dictType {
  type dict (line 60) | typedef struct dict {
  type dictIterator (line 69) | typedef struct dictIterator {

FILE: deps/hiredis/examples/example-ae.c
  function getCallback (line 13) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 22) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 32) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 43) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-glib.c
  function connect_cb (line 9) | static void
  function disconnect_cb (line 21) | static void
  function command_cb (line 33) | static void
  function gint (line 47) | gint

FILE: deps/hiredis/examples/example-ivykis.c
  function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 19) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 27) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 35) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libev.c
  function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 19) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 27) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 35) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libevent-ssl.c
  function getCallback (line 11) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 20) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 28) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 36) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libevent.c
  function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 24) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 32) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 40) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libhv.c
  function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function debugCallback (line 19) | void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 31) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 39) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 47) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libsdevent.c
  function debugCallback (line 10) | void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
  function getCallback (line 22) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 34) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 42) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 50) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-libuv.c
  function debugCallback (line 10) | void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
  function getCallback (line 22) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 34) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 42) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 50) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-macosx.c
  function getCallback (line 12) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 21) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 29) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 38) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-poll.c
  function getCallback (line 13) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 22) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 32) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function main (line 42) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-push.c
  function assertReplyAndFree (line 43) | static void assertReplyAndFree(redisContext *context, redisReply *reply,...
  function enableClientTracking (line 58) | static void enableClientTracking(redisContext *c) {
  function pushReplyHandler (line 78) | void pushReplyHandler(void *privdata, void *r) {
  function privdata_dtor (line 101) | void privdata_dtor(void *privdata) {
  function main (line 106) | int main(int argc, char **argv) {

FILE: deps/hiredis/examples/example-qt.cpp
  function getCallback (line 9) | void getCallback(redisAsyncContext *, void * r, void * privdata) {
  function main (line 36) | int main (int argc, char **argv) {

FILE: deps/hiredis/examples/example-qt.h
  function class (line 6) | class ExampleQt : public QObject {

FILE: deps/hiredis/examples/example-redismoduleapi.c
  function debugCallback (line 10) | void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
  function getCallback (line 22) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
  function connectCallback (line 36) | void connectCallback(const redisAsyncContext *c, int status) {
  function disconnectCallback (line 44) | void disconnectCallback(const redisAsyncContext *c, int status) {
  function RedisModule_OnLoad (line 62) | int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, in...

FILE: deps/hiredis/examples/example-ssl.c
  function main (line 12) | int main(int argc, char **argv) {

FILE: deps/hiredis/examples/example.c
  function example_argv_command (line 10) | static void example_argv_command(redisContext *c, size_t n) {
  function main (line 58) | int main(int argc, char **argv) {

FILE: deps/hiredis/fuzzing/format_command_fuzzer.c
  function LLVMFuzzerTestOneInput (line 38) | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

FILE: deps/hiredis/hiredis.c
  type timeval (line 47) | struct timeval
  type timeval (line 48) | struct timeval
  function redisReply (line 80) | static redisReply *createReplyObject(int type) {
  function freeReplyObject (line 91) | void freeReplyObject(void *reply) {
  function countDigits (line 299) | static uint32_t countDigits(uint64_t v) {
  function bulklen (line 312) | static size_t bulklen(size_t len) {
  function redisvFormatCommand (line 316) | int redisvFormatCommand(char **target, const char *format, va_list ap) {
  function redisFormatCommand (line 565) | int redisFormatCommand(char **target, const char *format, ...) {
  function redisFormatSdsCommandArgv (line 586) | long long redisFormatSdsCommandArgv(hisds *target, int argc, const char ...
  function redisFreeSdsCommand (line 633) | void redisFreeSdsCommand(hisds cmd) {
  function redisFormatCommandArgv (line 642) | long long redisFormatCommandArgv(char **target, int argc, const char **a...
  function redisFreeCommand (line 680) | void redisFreeCommand(char *cmd) {
  function __redisSetError (line 684) | void __redisSetError(redisContext *c, int type, const char *str) {
  function redisReader (line 700) | redisReader *redisReaderCreate(void) {
  function redisPushAutoFree (line 704) | static void redisPushAutoFree(void *privdata, void *reply) {
  function redisContext (line 709) | static redisContext *redisContextInit(void) {
  function redisFree (line 730) | void redisFree(redisContext *c) {
  function redisFD (line 757) | redisFD redisFreeKeepFd(redisContext *c) {
  function redisReconnect (line 764) | int redisReconnect(redisContext *c) {
  function redisContext (line 808) | redisContext *redisConnectWithOptions(const redisOptions *options) {
  function redisContext (line 875) | redisContext *redisConnect(const char *ip, int port) {
  function redisContext (line 881) | redisContext *redisConnectWithTimeout(const char *ip, int port, const st...
  function redisContext (line 888) | redisContext *redisConnectNonBlock(const char *ip, int port) {
  function redisContext (line 895) | redisContext *redisConnectBindNonBlock(const char *ip, int port,
  function redisContext (line 904) | redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
  function redisContext (line 913) | redisContext *redisConnectUnix(const char *path) {
  function redisContext (line 919) | redisContext *redisConnectUnixWithTimeout(const char *path, const struct...
  function redisContext (line 926) | redisContext *redisConnectUnixNonBlock(const char *path) {
  function redisContext (line 933) | redisContext *redisConnectFd(redisFD fd) {
  function redisSetTimeout (line 941) | int redisSetTimeout(redisContext *c, const struct timeval tv) {
  function redisEnableKeepAliveWithInterval (line 947) | int redisEnableKeepAliveWithInterval(redisContext *c, int interval) {
  function redisEnableKeepAlive (line 952) | int redisEnableKeepAlive(redisContext *c) {
  function redisSetTcpUserTimeout (line 957) | int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
  function redisPushFn (line 962) | redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) {
  function redisBufferRead (line 973) | int redisBufferRead(redisContext *c) {
  function redisBufferWrite (line 1001) | int redisBufferWrite(redisContext *c, int *done) {
  function redisHandledPushReply (line 1032) | static int redisHandledPushReply(redisContext *c, void *reply) {
  function redisGetReplyFromReader (line 1042) | int redisGetReplyFromReader(redisContext *c, void **reply) {
  function redisNextInBandReplyFromReader (line 1054) | static int redisNextInBandReplyFromReader(redisContext *c, void **reply) {
  function redisGetReply (line 1063) | int redisGetReply(redisContext *c, void **reply) {
  function __redisAppendCommand (line 1106) | int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) {
  function redisAppendFormattedCommand (line 1119) | int redisAppendFormattedCommand(redisContext *c, const char *cmd, size_t...
  function redisvAppendCommand (line 1128) | int redisvAppendCommand(redisContext *c, const char *format, va_list ap) {
  function redisAppendCommand (line 1150) | int redisAppendCommand(redisContext *c, const char *format, ...) {
  function redisAppendCommandArgv (line 1160) | int redisAppendCommandArgv(redisContext *c, int argc, const char **argv,...

FILE: deps/hiredis/hiredis.h
  type timeval (line 41) | struct timeval
  type redisAsyncContext (line 107) | struct redisAsyncContext
  type redisContext (line 108) | struct redisContext
  type redisAsyncContext (line 113) | struct redisAsyncContext
  type redisReply (line 120) | typedef struct redisReply {
  type redisConnectionType (line 147) | enum redisConnectionType {
  type redisSsl (line 153) | struct redisSsl
  type redisFD (line 174) | typedef int redisFD;
  type redisFD (line 178) | typedef unsigned long long redisFD;
  type redisFD (line 180) | typedef unsigned long redisFD;
  type redisOptions (line 185) | typedef struct {
  type redisContextFuncs (line 241) | typedef struct redisContextFuncs {
  type redisContext (line 257) | typedef struct redisContext {
  type timeval (line 300) | struct timeval
  type timeval (line 307) | struct timeval
  type timeval (line 323) | struct timeval

FILE: deps/hiredis/hiredis_ssl.h
  type ssl_st (line 42) | struct ssl_st
  type redisSSLContext (line 47) | typedef struct redisSSLContext redisSSLContext;
  type redisSSLContextError (line 53) | typedef enum {
  type redisSSLOptions (line 77) | typedef struct {
  type ssl_st (line 157) | struct ssl_st

FILE: deps/hiredis/net.c
  type timeval (line 53) | struct timeval
  function redisNetClose (line 55) | void redisNetClose(redisContext *c) {
  function redisNetRead (line 62) | ssize_t redisNetRead(redisContext *c, char *buf, size_t bufcap) {
  function redisNetWrite (line 84) | ssize_t redisNetWrite(redisContext *c) {
  function __redisSetErrorFromErrno (line 101) | static void __redisSetErrorFromErrno(redisContext *c, int type, const ch...
  function redisSetReuseAddr (line 112) | static int redisSetReuseAddr(redisContext *c) {
  function redisCreateSocket (line 122) | static int redisCreateSocket(redisContext *c, int type) {
  function redisSetBlocking (line 137) | static int redisSetBlocking(redisContext *c, int blocking) {
  function redisKeepAlive (line 171) | int redisKeepAlive(redisContext *c, int interval) {
  function redisSetTcpNoDelay (line 221) | int redisSetTcpNoDelay(redisContext *c) {
  function redisContextSetTcpUserTimeout (line 231) | int redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
  function redisContextTimeoutMsec (line 250) | static int redisContextTimeoutMsec(redisContext *c, long *result)
  function redisContextWaitReady (line 274) | static int redisContextWaitReady(redisContext *c, long msec) {
  function redisCheckConnectDone (line 307) | int redisCheckConnectDone(redisContext *c, int *completed) {
  function redisCheckSocketError (line 343) | int redisCheckSocketError(redisContext *c) {
  function redisContextSetTimeout (line 365) | int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
  function redisContextUpdateConnectTimeout (line 384) | int redisContextUpdateConnectTimeout(redisContext *c, const struct timev...
  function redisContextUpdateCommandTimeout (line 400) | int redisContextUpdateCommandTimeout(redisContext *c, const struct timev...
  function _redisContextConnectTcp (line 416) | static int _redisContextConnectTcp(redisContext *c, const char *addr, in...
  function redisContextConnectTcp (line 596) | int redisContextConnectTcp(redisContext *c, const char *addr, int port,
  function redisContextConnectBindTcp (line 601) | int redisContextConnectBindTcp(redisContext *c, const char *addr, int port,
  function redisContextConnectUnix (line 607) | int redisContextConnectUnix(redisContext *c, const char *path, const str...

FILE: deps/hiredis/net.h
  type timeval (line 45) | struct timeval
  type timeval (line 46) | struct timeval
  type timeval (line 48) | struct timeval
  type timeval (line 50) | struct timeval

FILE: deps/hiredis/read.c
  function __redisReaderSetError (line 53) | static void __redisReaderSetError(redisReader *r, int type, const char *...
  function chrtos (line 77) | static size_t chrtos(char *buf, size_t size, char byte) {
  function __redisReaderSetErrorProtocolByte (line 101) | static void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {
  function __redisReaderSetErrorOOM (line 110) | static void __redisReaderSetErrorOOM(redisReader *r) {
  function string2ll (line 162) | static int string2ll(const char *s, size_t slen, long long *value) {
  function moveToNextTask (line 240) | static void moveToNextTask(redisReader *r) {
  function processLineItem (line 268) | static int processLineItem(redisReader *r) {
  function processBulkItem (line 397) | static int processBulkItem(redisReader *r) {
  function redisReaderGrow (line 469) | static int redisReaderGrow(redisReader *r) {
  function processAggregateItem (line 495) | static int processAggregateItem(redisReader *r) {
  function processItem (line 573) | static int processItem(redisReader *r) {
  function redisReader (line 654) | redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *f...
  function redisReaderFree (line 686) | void redisReaderFree(redisReader *r) {
  function redisReaderFeed (line 706) | int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
  function redisReaderGetReply (line 737) | int redisReaderGetReply(redisReader *r, void **reply) {

FILE: deps/hiredis/read.h
  type redisReadTask (line 76) | typedef struct redisReadTask {
  type redisReplyObjectFunctions (line 85) | typedef struct redisReplyObjectFunctions {
  type redisReader (line 95) | typedef struct redisReader {

FILE: deps/hiredis/sds.c
  function hi_sdsHdrSize (line 43) | static inline int hi_sdsHdrSize(char type) {
  function hi_sdsReqType (line 59) | static inline char hi_sdsReqType(size_t string_size) {
  function hisds (line 83) | hisds hi_sdsnewlen(const void *init, size_t initlen) {
  function hisds (line 142) | hisds hi_sdsempty(void) {
  function hisds (line 147) | hisds hi_sdsnew(const char *init) {
  function hisds (line 153) | hisds hi_sdsdup(const hisds s) {
  function hi_sdsfree (line 158) | void hi_sdsfree(hisds s) {
  function hi_sdsupdatelen (line 177) | void hi_sdsupdatelen(hisds s) {
  function hi_sdsclear (line 186) | void hi_sdsclear(hisds s) {
  function hisds (line 197) | hisds hi_sdsMakeRoomFor(hisds s, size_t addlen) {
  function hisds (line 250) | hisds hi_sdsRemoveFreeSpace(hisds s) {
  function hi_sdsAllocSize (line 283) | size_t hi_sdsAllocSize(hisds s) {
  function hi_sdsIncrLen (line 317) | void hi_sdsIncrLen(hisds s, int incr) {
  function hisds (line 363) | hisds hi_sdsgrowzero(hisds s, size_t len) {
  function hisds (line 381) | hisds hi_sdscatlen(hisds s, const void *t, size_t len) {
  function hisds (line 396) | hisds hi_sdscat(hisds s, const char *t) {
  function hisds (line 404) | hisds hi_sdscatsds(hisds s, const hisds t) {
  function hisds (line 410) | hisds hi_sdscpylen(hisds s, const char *t, size_t len) {
  function hisds (line 423) | hisds hi_sdscpy(hisds s, const char *t) {
  function hi_sdsll2str (line 434) | int hi_sdsll2str(char *s, long long value) {
  function hi_sdsull2str (line 466) | int hi_sdsull2str(char *s, unsigned long long v) {
  function hisds (line 498) | hisds hi_sdsfromlonglong(long long value) {
  function hisds (line 506) | hisds hi_sdscatvprintf(hisds s, const char *fmt, va_list ap) {
  function hisds (line 559) | hisds hi_sdscatprintf(hisds s, const char *fmt, ...) {
  function hisds (line 584) | hisds hi_sdscatfmt(hisds s, char const *fmt, ...) {
  function hisds (line 694) | hisds hi_sdstrim(hisds s, const char *cset) {
  function hi_sdsrange (line 729) | int hi_sdsrange(hisds s, ssize_t start, ssize_t end) {
  function hi_sdstolower (line 760) | void hi_sdstolower(hisds s) {
  function hi_sdstoupper (line 767) | void hi_sdstoupper(hisds s) {
  function hi_sdscmp (line 784) | int hi_sdscmp(const hisds s1, const hisds s2) {
  function hisds (line 812) | hisds *hi_sdssplitlen(const char *s, int len, const char *sep, int seple...
  function hi_sdsfreesplitres (line 862) | void hi_sdsfreesplitres(hisds *tokens, int count) {
  function hisds (line 875) | hisds hi_sdscatrepr(hisds s, const char *p, size_t len) {
  function hi_hex_digit_to_int (line 902) | static int hi_hex_digit_to_int(char c) {
  function hisds (line 943) | hisds *hi_sdssplitargs(const char *line, int *argc) {
  function hisds (line 1070) | hisds hi_sdsmapchars(hisds s, const char *from, const char *to, size_t s...
  function hisds (line 1086) | hisds hi_sdsjoin(char **argv, int argc, char *sep) {
  function hisds (line 1098) | hisds hi_sdsjoinsds(hisds *argv, int argc, const char *sep, size_t seple...
  function hi_sds_free (line 1116) | void hi_sds_free(void *ptr) { hi_s_free(ptr); }
  function hi_sdsTest (line 1124) | int hi_sdsTest(void) {
  function main (line 1289) | int main(void) {

FILE: deps/hiredis/sds.h
  type hisdshdr5 (line 53) | struct __attribute__ ((__packed__)) hisdshdr5 {
  type hisdshdr8 (line 57) | struct __attribute__ ((__packed__)) hisdshdr8 {
  type hisdshdr16 (line 63) | struct __attribute__ ((__packed__)) hisdshdr16 {
  type hisdshdr32 (line 69) | struct __attribute__ ((__packed__)) hisdshdr32 {
  type hisdshdr64 (line 75) | struct __attribute__ ((__packed__)) hisdshdr64 {
  function hi_sdslen (line 93) | static inline size_t hi_sdslen(const hisds s) {
  function hi_sdsavail (line 110) | static inline size_t hi_sdsavail(const hisds s) {
  function hi_sdssetlen (line 136) | static inline void hi_sdssetlen(hisds s, size_t newlen) {
  function hi_sdsinclen (line 160) | static inline void hi_sdsinclen(hisds s, size_t inc) {
  function hi_sdsalloc (line 186) | static inline size_t hi_sdsalloc(const hisds s) {
  function hi_sdssetalloc (line 203) | static inline void hi_sdssetalloc(hisds s, size_t newlen) {

FILE: deps/hiredis/sockcompat.c
  function _wsaErrorToErrno (line 35) | static int _wsaErrorToErrno(int err) {
  function _updateErrno (line 97) | static void _updateErrno(int success) {
  function _initWinsock (line 101) | static int _initWinsock() {
  function win32_getaddrinfo (line 115) | int win32_getaddrinfo(const char *node, const char *service, const struc...
  function win32_freeaddrinfo (line 149) | void win32_freeaddrinfo(struct addrinfo *res) {
  function SOCKET (line 153) | SOCKET win32_socket(int domain, int type, int protocol) {
  function win32_ioctl (line 165) | int win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp) {
  function win32_bind (line 171) | int win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t add...
  function win32_connect (line 177) | int win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t ...
  function win32_getsockopt (line 198) | int win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval...
  function win32_setsockopt (line 227) | int win32_setsockopt(SOCKET sockfd, int level, int optname, const void *...
  function win32_close (line 240) | int win32_close(SOCKET fd) {
  function win32_recv (line 246) | ssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags) {
  function win32_send (line 252) | ssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags) {
  function win32_poll (line 258) | int win32_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
  function win32_redisKeepAlive (line 264) | int win32_redisKeepAlive(SOCKET sockfd, int interval_ms) {

FILE: deps/hiredis/sockcompat.h
  type addrinfo (line 60) | struct addrinfo
  type addrinfo (line 60) | struct addrinfo
  type addrinfo (line 62) | struct addrinfo
  type sockaddr (line 65) | struct sockaddr
  type sockaddr (line 66) | struct sockaddr
  type ULONG (line 72) | typedef ULONG nfds_t;
  type pollfd (line 73) | struct pollfd

FILE: deps/hiredis/ssl.c
  type redisSSLContext (line 66) | struct redisSSLContext {
  type redisSSL (line 75) | typedef struct redisSSL {
  type CRITICAL_SECTION (line 111) | typedef CRITICAL_SECTION sslLockType;
  function sslLockInit (line 112) | static void sslLockInit(sslLockType* l) {
  function sslLockAcquire (line 115) | static void sslLockAcquire(sslLockType* l) {
  function sslLockRelease (line 118) | static void sslLockRelease(sslLockType* l) {
  type pthread_mutex_t (line 122) | typedef pthread_mutex_t sslLockType;
  function sslLockInit (line 123) | static void sslLockInit(sslLockType *l) {
  function sslLockAcquire (line 126) | static void sslLockAcquire(sslLockType *l) {
  function sslLockRelease (line 129) | static void sslLockRelease(sslLockType *l) {
  function opensslDoLock (line 136) | static void opensslDoLock(int mode, int lkid, const char *f, int line) {
  function initOpensslLocks (line 149) | static int initOpensslLocks(void) {
  function redisInitOpenSSL (line 168) | int redisInitOpenSSL(void)
  function redisFreeSSLContext (line 206) | void redisFreeSSLContext(redisSSLContext *ctx)
  function redisSSLContext (line 229) | redisSSLContext *redisCreateSSLContext(const char *cacert_filename, cons...
  function redisSSLContext (line 245) | redisSSLContext *redisCreateSSLContextWithOptions(redisSSLOptions *optio...
  function redisSSLConnect (line 355) | static int redisSSLConnect(redisContext *c, SSL *ssl) {
  function redisInitiateSSL (line 409) | int redisInitiateSSL(redisContext *c, SSL *ssl) {
  function redisInitiateSSLWithContext (line 418) | int redisInitiateSSLWithContext(redisContext *c, redisSSLContext *redis_...
  function maybeCheckWant (line 454) | static int maybeCheckWant(redisSSL *rssl, int rv) {
  function redisSSLFree (line 474) | static void redisSSLFree(void *privctx){
  function redisSSLRead (line 485) | static ssize_t redisSSLRead(redisContext *c, char *buf, size_t bufcap) {
  function redisSSLWrite (line 527) | static ssize_t redisSSLWrite(redisContext *c) {
  function redisSSLAsyncRead (line 549) | static void redisSSLAsyncRead(redisAsyncContext *ac) {
  function redisSSLAsyncWrite (line 579) | static void redisSSLAsyncWrite(redisAsyncContext *ac) {

FILE: deps/hiredis/test.c
  type connection_type (line 29) | enum connection_type {
  type config (line 36) | struct config {
  type privdata (line 58) | struct privdata {
  type pushCounters (line 62) | struct pushCounters {
  function millisleep (line 79) | static void millisleep(int ms)
  function usec (line 88) | static long long usec(void) {
  function get_redis_version (line 109) | void get_redis_version(redisContext *c, int *majorptr, int *minorptr) {
  function redisContext (line 144) | static redisContext *select_database(redisContext *c) {
  function send_hello (line 167) | static void send_hello(redisContext *c, int version) {
  function send_client_tracking (line 178) | static void send_client_tracking(redisContext *c, const char *str) {
  function disconnect (line 186) | static int disconnect(redisContext *c, int keep_fd) {
  function do_ssl_handshake (line 204) | static void do_ssl_handshake(redisContext *c) {
  function redisContext (line 217) | static redisContext *do_connect(struct config config) {
  function do_reconnect (line 254) | static void do_reconnect(redisContext *c, struct config config) {
  function test_format_commands (line 262) | static void test_format_commands(void) {
  function test_append_formatted_commands (line 386) | static void test_append_formatted_commands(struct config config) {
  function test_tcp_options (line 408) | static void test_tcp_options(struct config cfg) {
  function test_reply_reader (line 427) | static void test_reply_reader(void) {
  function test_free_null (line 821) | static void test_free_null(void) {
  function test_allocator_injection (line 858) | static void test_allocator_injection(void) {
  function test_blocking_connection_errors (line 892) | static void test_blocking_connection_errors(void) {
  function push_handler (line 950) | void push_handler(void *privdata, void *r) {
  function push_handler_async (line 971) | void push_handler_async(redisAsyncContext *ac, void *reply) {
  function test_resp3_push_handler (line 976) | static void test_resp3_push_handler(redisContext *c) {
  function redisOptions (line 1050) | redisOptions get_redis_tcp_options(struct config config) {
  function test_resp3_push_options (line 1056) | static void test_resp3_push_options(struct config config) {
  function free_privdata (line 1095) | void free_privdata(void *privdata) {
  function test_privdata_hooks (line 1100) | static void test_privdata_hooks(struct config config) {
  function test_blocking_connection (line 1116) | static void test_blocking_connection(struct config config) {
  function detect_debug_sleep (line 1214) | static int detect_debug_sleep(redisContext *c) {
  function test_blocking_connection_timeouts (line 1230) | static void test_blocking_connection_timeouts(struct config config) {
  function test_blocking_io_errors (line 1296) | static void test_blocking_io_errors(struct config config) {
  function test_invalid_timeout_errors (line 1342) | static void test_invalid_timeout_errors(struct config config) {
  function test_throughput (line 1390) | static void test_throughput(struct config config) {
  type event_base (line 1582) | struct event_base
  type TestState (line 1584) | typedef struct TestState {
  function async_disconnect (line 1592) | void async_disconnect(redisAsyncContext *ac) {
  function timeout_cb (line 1598) | void timeout_cb(int fd, short event, void *arg) {
  function unexpected_cb (line 1605) | void unexpected_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function publish_msg (line 1612) | void publish_msg(redisOptions *options, const char* channel, const char*...
  function integer_cb (line 1622) | void integer_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function subscribe_cb (line 1633) | void subscribe_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function array_cb (line 1669) | void array_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function null_cb (line 1678) | void null_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function test_pubsub_handling (line 1685) | static void test_pubsub_handling(struct config config) {
  function unexpected_push_cb (line 1719) | void unexpected_push_cb(redisAsyncContext *ac, void *r) {
  function test_pubsub_handling_resp3 (line 1725) | static void test_pubsub_handling_resp3(struct config config) {
  function subscribe_with_timeout_cb (line 1772) | void subscribe_with_timeout_cb(redisAsyncContext *ac, void *r, void *pri...
  function test_command_timeout_during_pubsub (line 1806) | static void test_command_timeout_during_pubsub(struct config config) {
  function subscribe_channel_a_cb (line 1847) | void subscribe_channel_a_cb(redisAsyncContext *ac, void *r, void *privda...
  function subscribe_channel_b_cb (line 1884) | void subscribe_channel_b_cb(redisAsyncContext *ac, void *r, void *privda...
  function test_pubsub_multiple_channels (line 1911) | static void test_pubsub_multiple_channels(struct config config) {
  function monitor_cb (line 1946) | void monitor_cb(redisAsyncContext *ac, void *r, void *privdata) {
  function test_monitor (line 1988) | static void test_monitor(struct config config) {
  type astest_no (line 2025) | typedef enum astest_no
  type _astest (line 2036) | struct _astest {
  type _astest (line 2049) | struct _astest
  function asCleanup (line 2052) | static void asCleanup(void* data)
  type redisAsyncContext (line 2058) | struct redisAsyncContext
  function connectCallback (line 2060) | static void connectCallback(redisAsyncContext *c, int status) {
  function disconnectCallback (line 2079) | static void disconnectCallback(const redisAsyncContext *c, int status) {
  function commandCallback (line 2089) | static void commandCallback(struct redisAsyncContext *ac, void* _reply, ...
  function redisAsyncContext (line 2118) | static redisAsyncContext *do_aconnect(struct config config, astest_no te...
  function as_printerr (line 2158) | static void as_printerr(void) {
  function test_async_polling (line 2168) | static void test_async_polling(struct config config) {
  function main (line 2266) | int main(int argc, char **argv) {

FILE: deps/hiredis/win32.h
  function c99_vsnprintf (line 26) | __inline int c99_vsnprintf(char* str, size_t size, const char* format, v...
  function c99_snprintf (line 38) | __inline int c99_snprintf(char* str, size_t size, const char* format, ...)

FILE: deps/jemalloc/include/jemalloc/internal/activity_callback.h
  type activity_callback_thunk_t (line 17) | typedef struct activity_callback_thunk_s activity_callback_thunk_t;
  type activity_callback_thunk_s (line 18) | struct activity_callback_thunk_s {

FILE: deps/jemalloc/include/jemalloc/internal/arena_inlines_a.h
  function arena_ind_get (line 4) | static inline unsigned
  function arena_internal_add (line 9) | static inline void
  function arena_internal_sub (line 14) | static inline void
  function arena_internal_get (line 19) | static inline size_t

FILE: deps/jemalloc/include/jemalloc/internal/arena_inlines_b.h
  function arena_t (line 14) | static inline arena_t *
  function JEMALLOC_ALWAYS_INLINE (line 20) | JEMALLOC_ALWAYS_INLINE arena_t *
  function JEMALLOC_ALWAYS_INLINE (line 41) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 74) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 96) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 108) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 117) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 139) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 144) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 165) | JEMALLOC_ALWAYS_INLINE arena_t *
  function JEMALLOC_ALWAYS_INLINE (line 172) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 182) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 213) | JEMALLOC_ALWAYS_INLINE bool
  function arena_dalloc_large_no_tcache (line 242) | static inline void
  function arena_dalloc_no_tcache (line 257) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 280) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 301) | JEMALLOC_ALWAYS_INLINE void
  function arena_sdalloc_no_tcache (line 339) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 378) | JEMALLOC_ALWAYS_INLINE void
  function arena_cache_oblivious_randomize (line 426) | static inline void
  type arena_dalloc_bin_locked_info_t (line 458) | typedef struct arena_dalloc_bin_locked_info_s arena_dalloc_bin_locked_in...
  type arena_dalloc_bin_locked_info_s (line 459) | struct arena_dalloc_bin_locked_info_s {
  function JEMALLOC_ALWAYS_INLINE (line 465) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 487) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 503) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 534) | JEMALLOC_ALWAYS_INLINE void
  function bin_t (line 544) | static inline bin_t *

FILE: deps/jemalloc/include/jemalloc/internal/arena_stats.h
  type arena_stats_large_s (line 13) | struct arena_stats_large_s
  type arena_stats_large_s (line 14) | struct arena_stats_large_s {
  type arena_stats_t (line 45) | typedef struct arena_stats_s arena_stats_t;
  type arena_stats_s (line 46) | struct arena_stats_s {
  function arena_stats_init (line 87) | static inline bool
  function arena_stats_large_flush_nrequests_add (line 102) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/arena_structs.h
  type arena_s (line 20) | struct arena_s {

FILE: deps/jemalloc/include/jemalloc/internal/arena_types.h
  type arena_decay_t (line 12) | typedef struct arena_decay_s arena_decay_t;
  type arena_t (line 13) | typedef struct arena_s arena_t;
  type percpu_arena_mode_t (line 15) | typedef enum {
  type arena_config_s (line 44) | struct arena_config_s {
  type arena_config_t (line 54) | typedef struct arena_config_s arena_config_t;

FILE: deps/jemalloc/include/jemalloc/internal/atomic_gcc_atomic.h
  type atomic_memory_order_t (line 8) | typedef enum {
  function ATOMIC_INLINE (line 16) | ATOMIC_INLINE int
  function ATOMIC_INLINE (line 34) | ATOMIC_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/atomic_gcc_sync.h
  type atomic_memory_order_t (line 6) | typedef enum {
  function ATOMIC_INLINE (line 14) | ATOMIC_INLINE void
  function ATOMIC_INLINE (line 65) | ATOMIC_INLINE void
  function ATOMIC_INLINE (line 75) | ATOMIC_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/atomic_msvc.h
  type atomic_memory_order_t (line 6) | typedef enum {
  type atomic_repr_0_t (line 14) | typedef char atomic_repr_0_t;
  type atomic_repr_1_t (line 15) | typedef short atomic_repr_1_t;
  type atomic_repr_2_t (line 16) | typedef long atomic_repr_2_t;
  type __int64 (line 17) | typedef __int64 atomic_repr_3_t;
  function ATOMIC_INLINE (line 19) | ATOMIC_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/background_thread_inlines.h
  function JEMALLOC_ALWAYS_INLINE (line 4) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 9) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 15) | JEMALLOC_ALWAYS_INLINE background_thread_info_t *
  function JEMALLOC_ALWAYS_INLINE (line 21) | JEMALLOC_ALWAYS_INLINE background_thread_info_t *
  function JEMALLOC_ALWAYS_INLINE (line 26) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 43) | JEMALLOC_ALWAYS_INLINE bool

FILE: deps/jemalloc/include/jemalloc/internal/background_thread_structs.h
  type background_thread_state_t (line 25) | typedef enum {
  type background_thread_info_s (line 32) | struct background_thread_info_s {
  type background_thread_info_t (line 56) | typedef struct background_thread_info_s background_thread_info_t;
  type background_thread_stats_s (line 58) | struct background_thread_stats_s {
  type background_thread_stats_t (line 64) | typedef struct background_thread_stats_s background_thread_stats_t;

FILE: deps/jemalloc/include/jemalloc/internal/base.h
  type metadata_thp_mode_e (line 8) | enum metadata_thp_mode_e {
  type metadata_thp_mode_t (line 22) | typedef enum metadata_thp_mode_e metadata_thp_mode_t;
  type base_block_t (line 30) | typedef struct base_block_s base_block_t;
  type base_block_s (line 31) | struct base_block_s {
  type base_t (line 42) | typedef struct base_s base_t;
  type base_s (line 43) | struct base_s {
  function base_ind_get (line 83) | static inline unsigned
  function metadata_thp_enabled (line 88) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/bin.h
  type bin_t (line 14) | typedef struct bin_s bin_t;
  type bin_s (line 15) | struct bin_s {
  type bins_t (line 45) | typedef struct bins_s bins_t;
  type bins_s (line 46) | struct bins_s {
  function bin_stats_merge (line 64) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/bin_info.h
  type bin_info_t (line 25) | typedef struct bin_info_s bin_info_t;
  type bin_info_s (line 26) | struct bin_info_s {

FILE: deps/jemalloc/include/jemalloc/internal/bin_stats.h
  type bin_stats_t (line 6) | typedef struct bin_stats_s bin_stats_t;
  type bin_stats_s (line 7) | struct bin_stats_s {
  type bin_stats_data_t (line 52) | typedef struct bin_stats_data_s bin_stats_data_t;
  type bin_stats_data_s (line 53) | struct bin_stats_data_s {

FILE: deps/jemalloc/include/jemalloc/internal/bin_types.h
  type tsd_binshards_t (line 12) | typedef struct tsd_binshards_s tsd_binshards_t;
  type tsd_binshards_s (line 13) | struct tsd_binshards_s {

FILE: deps/jemalloc/include/jemalloc/internal/bit_util.h
  function ffs_llu (line 19) | static inline unsigned
  function ffs_lu (line 25) | static inline unsigned
  function ffs_u (line 31) | static inline unsigned
  function fls_llu_slow (line 61) | static inline unsigned
  function fls_lu_slow (line 66) | static inline unsigned
  function fls_u_slow (line 71) | static inline unsigned
  function fls_llu (line 79) | static inline unsigned
  function fls_lu (line 97) | static inline unsigned
  function fls_u (line 103) | static inline unsigned
  function fls_llu (line 147) | unsigned
  function fls_lu (line 152) | static inline unsigned
  function fls_u (line 157) | static inline unsigned
  function fls_llu (line 166) | static inline unsigned
  function fls_lu (line 171) | static inline unsigned
  function fls_u (line 176) | static inline unsigned
  function popcount_u_slow (line 230) | unsigned
  function popcount_lu_slow (line 235) | static inline unsigned
  function popcount_llu_slow (line 240) | static inline unsigned
  function popcount_u (line 247) | static inline unsigned
  function popcount_lu (line 256) | static inline unsigned
  function popcount_llu (line 265) | static inline unsigned
  function cfs_lu (line 279) | static inline size_t
  function ffs_zu (line 287) | static inline unsigned
  function fls_zu (line 300) | static inline unsigned
  function ffs_u64 (line 314) | static inline unsigned
  function fls_u64 (line 325) | static inline unsigned
  function ffs_u32 (line 336) | static inline unsigned
  function fls_u32 (line 346) | static inline unsigned
  function pow2_ceil_u64 (line 356) | static inline uint64_t
  function pow2_ceil_u32 (line 370) | static inline uint32_t
  function pow2_ceil_zu (line 382) | static inline size_t
  function lg_floor (line 391) | static inline unsigned
  function lg_ceil (line 401) | static inline unsigned

FILE: deps/jemalloc/include/jemalloc/internal/bitmap.h
  type bitmap_t (line 7) | typedef unsigned long bitmap_t;
  type bitmap_info_t (line 151) | typedef struct bitmap_info_s {
  function bitmap_full (line 174) | static inline bool
  function bitmap_get (line 193) | static inline bool
  function bitmap_set (line 204) | static inline void
  function bitmap_ffu (line 240) | static inline size_t
  function bitmap_sfu (line 299) | static inline size_t
  function bitmap_unset (line 329) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/buf_writer.h
  type buf_writer_t (line 13) | typedef struct {

FILE: deps/jemalloc/include/jemalloc/internal/cache_bin.h
  type cache_bin_sz_t (line 21) | typedef uint16_t cache_bin_sz_t;
  type cache_bin_stats_t (line 49) | typedef struct cache_bin_stats_s cache_bin_stats_t;
  type cache_bin_stats_s (line 50) | struct cache_bin_stats_s {
  type cache_bin_info_t (line 62) | typedef struct cache_bin_info_s cache_bin_info_t;
  type cache_bin_info_s (line 63) | struct cache_bin_info_s {
  type cache_bin_t (line 81) | typedef struct cache_bin_s cache_bin_t;
  type cache_bin_s (line 82) | struct cache_bin_s {
  type cache_bin_array_descriptor_t (line 133) | typedef struct cache_bin_array_descriptor_s cache_bin_array_descriptor_t;
  type cache_bin_array_descriptor_s (line 134) | struct cache_bin_array_descriptor_s {
  function cache_bin_array_descriptor_init (line 144) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 151) | JEMALLOC_ALWAYS_INLINE bool
  function cache_bin_sz_t (line 172) | static inline cache_bin_sz_t
  function cache_bin_assert_earlier (line 183) | static inline void
  function cache_bin_diff (line 196) | static inline uint16_t
  function cache_bin_sz_t (line 214) | static inline cache_bin_sz_t
  function cache_bin_sz_t (line 237) | static inline cache_bin_sz_t
  function cache_bin_low_bits_low_bound_get (line 276) | static inline uint16_t
  function cache_bin_assert_empty (line 300) | static inline void
  function cache_bin_sz_t (line 311) | static inline cache_bin_sz_t
  function cache_bin_sz_t (line 318) | static inline cache_bin_sz_t
  function cache_bin_low_water_set (line 334) | static inline void
  function cache_bin_low_water_adjust (line 339) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 347) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 396) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 406) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 411) | JEMALLOC_ALWAYS_INLINE cache_bin_sz_t
  function JEMALLOC_ALWAYS_INLINE (line 425) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 433) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 448) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 476) | JEMALLOC_ALWAYS_INLINE cache_bin_sz_t
  function JEMALLOC_ALWAYS_INLINE (line 504) | JEMALLOC_ALWAYS_INLINE cache_bin_sz_t
  function cache_bin_nitems_get_remote (line 516) | static inline void
  type cache_bin_ptr_array_t (line 546) | typedef struct cache_bin_ptr_array_s cache_bin_ptr_array_t;
  type cache_bin_ptr_array_s (line 547) | struct cache_bin_ptr_array_s {
  function cache_bin_init_ptr_array_for_fill (line 569) | static inline void
  function cache_bin_finish_fill (line 581) | static inline void
  function cache_bin_init_ptr_array_for_flush (line 597) | static inline void
  function cache_bin_finish_flush (line 605) | static inline void
  function cache_bin_init_ptr_array_for_stashed (line 615) | static inline void
  function cache_bin_finish_flush_stashed (line 627) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/ckh.h
  type ckhc_t (line 28) | typedef struct {
  type ckh_t (line 34) | typedef struct {

FILE: deps/jemalloc/include/jemalloc/internal/counter.h
  type counter_accum_t (line 6) | typedef struct counter_accum_s {
  function JEMALLOC_ALWAYS_INLINE (line 12) | JEMALLOC_ALWAYS_INLINE bool

FILE: deps/jemalloc/include/jemalloc/internal/ctl.h
  type ctl_node_t (line 14) | typedef struct ctl_node_s {
  type ctl_named_node_t (line 18) | typedef struct ctl_named_node_s {
  type ctl_indexed_node_t (line 28) | typedef struct ctl_indexed_node_s {
  type ctl_arena_stats_t (line 34) | typedef struct ctl_arena_stats_s {
  type ctl_stats_t (line 52) | typedef struct ctl_stats_s {
  type ctl_arena_t (line 65) | typedef struct ctl_arena_s ctl_arena_t;
  type ctl_arena_s (line 66) | struct ctl_arena_s {
  type ctl_arenas_t (line 84) | typedef struct ctl_arenas_s {

FILE: deps/jemalloc/include/jemalloc/internal/decay.h
  type decay_t (line 23) | typedef struct decay_s decay_t;
  type decay_s (line 24) | struct decay_s {
  function decay_ms_read (line 90) | static inline ssize_t
  function decay_npages_limit_get (line 99) | static inline size_t
  function decay_epoch_npages_delta (line 105) | static inline size_t
  function decay_epoch_duration_ns (line 116) | static inline uint64_t
  function decay_immediately (line 121) | static inline bool
  function decay_disabled (line 127) | static inline bool
  function decay_gradually (line 134) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/div.h
  type div_info_t (line 15) | typedef struct div_info_s div_info_t;
  type div_info_s (line 16) | struct div_info_s {
  function div_compute (line 25) | static inline size_t

FILE: deps/jemalloc/include/jemalloc/internal/ecache.h
  type ecache_t (line 8) | typedef struct ecache_s ecache_t;
  type ecache_s (line 9) | struct ecache_s {
  function ecache_npages_get (line 24) | static inline size_t
  function ecache_nextents_get (line 31) | static inline size_t
  function ecache_nbytes_get (line 38) | static inline size_t
  function ecache_ind_get (line 44) | static inline unsigned

FILE: deps/jemalloc/include/jemalloc/internal/edata.h
  type extent_state_e (line 22) | enum extent_state_e {
  type extent_state_t (line 31) | typedef enum extent_state_e extent_state_t;
  type extent_head_state_e (line 33) | enum extent_head_state_e {
  type extent_head_state_t (line 37) | typedef enum extent_head_state_e extent_head_state_t;
  type extent_pai_e (line 43) | enum extent_pai_e {
  type extent_pai_t (line 47) | typedef enum extent_pai_e extent_pai_t;
  type e_prof_info_s (line 49) | struct e_prof_info_s {
  type e_prof_info_t (line 63) | typedef struct e_prof_info_s e_prof_info_t;
  type edata_map_info_t (line 76) | typedef struct edata_map_info_s edata_map_info_t;
  type edata_map_info_s (line 77) | struct edata_map_info_s {
  type edata_cmp_summary_t (line 82) | typedef struct edata_cmp_summary_s edata_cmp_summary_t;
  type edata_cmp_summary_s (line 83) | struct edata_cmp_summary_s {
  type edata_t (line 89) | typedef struct edata_s edata_t;
  type edata_s (line 92) | struct edata_s {
  function edata_arena_ind_get (line 256) | static inline unsigned
  function szind_t (line 265) | static inline szind_t
  function szind_t (line 273) | static inline szind_t
  function edata_usize_get (line 280) | static inline size_t
  function edata_binshard_get (line 285) | static inline unsigned
  function edata_sn_get (line 293) | static inline uint64_t
  function extent_state_t (line 298) | static inline extent_state_t
  function edata_guarded_get (line 304) | static inline bool
  function edata_zeroed_get (line 310) | static inline bool
  function edata_committed_get (line 316) | static inline bool
  function extent_pai_t (line 322) | static inline extent_pai_t
  function edata_slab_get (line 328) | static inline bool
  function edata_nfree_get (line 334) | static inline unsigned
  function edata_size_get (line 355) | static inline size_t
  function edata_esn_get (line 360) | static inline size_t
  function edata_bsize_get (line 365) | static inline size_t
  function hpdata_t (line 370) | static inline hpdata_t *
  function slab_data_t (line 393) | static inline slab_data_t *
  function slab_data_t (line 399) | static inline const slab_data_t *
  function prof_tctx_t (line 405) | static inline prof_tctx_t *
  function nstime_t (line 411) | static inline const nstime_t *
  function edata_prof_alloc_size_get (line 416) | static inline size_t
  function prof_recent_t (line 421) | static inline prof_recent_t *
  function edata_arena_ind_set (line 427) | static inline void
  function edata_binshard_set (line 433) | static inline void
  function edata_addr_set (line 441) | static inline void
  function edata_size_set (line 446) | static inline void
  function edata_esn_set (line 452) | static inline void
  function edata_bsize_set (line 458) | static inline void
  function edata_ps_set (line 463) | static inline void
  function edata_szind_set (line 469) | static inline void
  function edata_nfree_set (line 476) | static inline void
  function edata_nfree_binshard_set (line 483) | static inline void
  function edata_nfree_inc (line 493) | static inline void
  function edata_nfree_dec (line 499) | static inline void
  function edata_nfree_sub (line 505) | static inline void
  function edata_sn_set (line 511) | static inline void
  function edata_state_set (line 516) | static inline void
  function edata_guarded_set (line 522) | static inline void
  function edata_zeroed_set (line 528) | static inline void
  function edata_committed_set (line 534) | static inline void
  function edata_pai_set (line 540) | static inline void
  function edata_slab_set (line 546) | static inline void
  function edata_prof_tctx_set (line 552) | static inline void
  function edata_prof_alloc_time_set (line 557) | static inline void
  function edata_prof_alloc_size_set (line 562) | static inline void
  function edata_prof_recent_alloc_set_dont_call_directly (line 567) | static inline void
  function edata_is_head_get (line 574) | static inline bool
  function edata_is_head_set (line 580) | static inline void
  function edata_state_in_transition (line 586) | static inline bool
  function edata_init (line 598) | static inline void
  function edata_binit (line 621) | static inline void
  function edata_esn_comp (line 641) | static inline int
  function edata_ead_comp (line 649) | static inline int
  function edata_cmp_summary_t (line 657) | static inline edata_cmp_summary_t
  function edata_cmp_summary_comp (line 663) | static inline int
  function edata_snad_comp (line 674) | static inline int
  function edata_esnead_comp (line 682) | static inline int

FILE: deps/jemalloc/include/jemalloc/internal/edata_cache.h
  type edata_cache_t (line 15) | typedef struct edata_cache_s edata_cache_t;
  type edata_cache_s (line 16) | struct edata_cache_s {
  type edata_cache_fast_t (line 36) | typedef struct edata_cache_fast_s edata_cache_fast_t;
  type edata_cache_fast_s (line 37) | struct edata_cache_fast_s {

FILE: deps/jemalloc/include/jemalloc/internal/ehooks.h
  type ehooks_t (line 21) | typedef struct ehooks_s ehooks_t;
  type ehooks_s (line 22) | struct ehooks_s {
  function ehooks_pre_reentrancy (line 84) | static inline void
  function ehooks_post_reentrancy (line 90) | static inline void
  function ehooks_ind_get (line 99) | static inline unsigned
  function ehooks_set_extent_hooks_ptr (line 104) | static inline void
  function extent_hooks_t (line 109) | static inline extent_hooks_t *
  function ehooks_are_default (line 114) | static inline bool
  function ehooks_dalloc_will_fail (line 125) | static inline bool
  function ehooks_split_will_fail (line 134) | static inline bool
  function ehooks_merge_will_fail (line 139) | static inline bool
  function ehooks_guard_will_fail (line 144) | static inline bool
  function ehooks_debug_zero_check (line 161) | static inline void
  function ehooks_dalloc (line 213) | static inline bool
  function ehooks_destroy (line 230) | static inline void
  function ehooks_commit (line 246) | static inline bool
  function ehooks_decommit (line 267) | static inline bool
  function ehooks_purge_lazy (line 284) | static inline bool
  function ehooks_purge_forced (line 304) | static inline bool
  function ehooks_split (line 332) | static inline bool
  function ehooks_merge (line 349) | static inline bool
  function ehooks_zero (line 366) | static inline void
  function ehooks_guard (line 382) | static inline bool
  function ehooks_unguard (line 397) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/emap.h
  type emap_t (line 16) | typedef struct emap_s emap_t;
  type emap_s (line 17) | struct emap_s {
  type emap_alloc_ctx_t (line 22) | typedef struct emap_alloc_ctx_t emap_alloc_ctx_t;
  type emap_alloc_ctx_t (line 23) | struct emap_alloc_ctx_t {
  type emap_full_alloc_ctx_t (line 28) | typedef struct emap_full_alloc_ctx_s emap_full_alloc_ctx_t;
  type emap_full_alloc_ctx_s (line 29) | struct emap_full_alloc_ctx_s {
  type emap_prepare_t (line 99) | typedef struct emap_prepare_s emap_prepare_t;
  type emap_prepare_s (line 100) | struct emap_prepare_s {
  function emap_assert_mapped (line 140) | static inline void
  function emap_assert_not_mapped (line 149) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 156) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 168) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 204) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 216) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 225) | JEMALLOC_ALWAYS_INLINE edata_t *
  function JEMALLOC_ALWAYS_INLINE (line 233) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 245) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 262) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 283) | JEMALLOC_ALWAYS_INLINE bool
  type emap_batch_lookup_result_t (line 313) | typedef union emap_batch_lookup_result_u emap_batch_lookup_result_t;
  function JEMALLOC_ALWAYS_INLINE (line 319) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/emitter.h
  type emitter_output_t (line 6) | typedef enum emitter_output_e emitter_output_t;
  type emitter_output_e (line 7) | enum emitter_output_e {
  type emitter_justify_t (line 13) | typedef enum emitter_justify_e emitter_justify_t;
  type emitter_justify_e (line 14) | enum emitter_justify_e {
  type emitter_type_t (line 21) | typedef enum emitter_type_e emitter_type_t;
  type emitter_type_e (line 22) | enum emitter_type_e {
  type emitter_col_t (line 39) | typedef struct emitter_col_s emitter_col_t;
  type emitter_col_s (line 40) | struct emitter_col_s {
  type emitter_row_t (line 62) | typedef struct emitter_row_s emitter_row_t;
  type emitter_row_s (line 63) | struct emitter_row_s {
  type emitter_t (line 67) | typedef struct emitter_s emitter_t;
  type emitter_s (line 68) | struct emitter_s {
  function emitter_outputs_json (line 80) | static inline bool
  function emitter_printf (line 88) | static inline void
  function emitter_print_value (line 124) | static inline void
  function emitter_nest_inc (line 194) | static inline void
  function emitter_nest_dec (line 200) | static inline void
  function emitter_indent (line 206) | static inline void
  function emitter_json_key_prefix (line 222) | static inline void
  function emitter_init (line 241) | static inline void
  function emitter_json_key (line 259) | static inline void
  function emitter_json_value (line 269) | static inline void
  function emitter_json_kv (line 281) | static inline void
  function emitter_json_array_begin (line 288) | static inline void
  function emitter_json_array_kv_begin (line 298) | static inline void
  function emitter_json_array_end (line 304) | static inline void
  function emitter_json_object_begin (line 317) | static inline void
  function emitter_json_object_kv_begin (line 327) | static inline void
  function emitter_json_object_end (line 333) | static inline void
  function emitter_table_dict_begin (line 350) | static inline void
  function emitter_table_dict_end (line 359) | static inline void
  function emitter_table_kv_note (line 366) | static inline void
  function emitter_table_kv (line 387) | static inline void
  function emitter_table_printf (line 397) | static inline void
  function emitter_table_row (line 407) | static inline void
  function emitter_row_init (line 420) | static inline void
  function emitter_col_init (line 425) | static inline void
  function emitter_kv_note (line 441) | static inline void
  function emitter_kv (line 456) | static inline void
  function emitter_dict_begin (line 463) | static inline void
  function emitter_dict_end (line 474) | static inline void
  function emitter_begin (line 483) | static inline void
  function emitter_end (line 500) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/eset.h
  type eset_bin_t (line 18) | typedef struct eset_bin_s eset_bin_t;
  type eset_bin_s (line 19) | struct eset_bin_s {
  type eset_bin_stats_t (line 31) | typedef struct eset_bin_stats_s eset_bin_stats_t;
  type eset_bin_stats_s (line 32) | struct eset_bin_stats_s {
  type eset_t (line 37) | typedef struct eset_s eset_t;
  type eset_s (line 38) | struct eset_s {

FILE: deps/jemalloc/include/jemalloc/internal/exp_grow.h
  type exp_grow_t (line 4) | typedef struct exp_grow_s exp_grow_t;
  type exp_grow_s (line 5) | struct exp_grow_s {
  function exp_grow_size_prepare (line 21) | static inline bool
  function exp_grow_size_commit (line 38) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/extent.h
  function JEMALLOC_ALWAYS_INLINE (line 63) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 83) | JEMALLOC_ALWAYS_INLINE bool

FILE: deps/jemalloc/include/jemalloc/internal/extent_dss.h
  type dss_prec_t (line 4) | typedef enum {

FILE: deps/jemalloc/include/jemalloc/internal/fb.h
  type fb_group_t (line 12) | typedef unsigned long fb_group_t;
  function fb_init (line 17) | static inline void
  function fb_empty (line 23) | static inline bool
  function fb_full (line 34) | static inline bool
  function fb_get (line 50) | static inline bool
  function fb_set (line 58) | static inline void
  function fb_unset (line 66) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 81) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 123) | JEMALLOC_ALWAYS_INLINE void
  function fb_set_range (line 134) | static inline void
  function fb_unset_range (line 141) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 147) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 154) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 162) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 174) | JEMALLOC_ALWAYS_INLINE ssize_t
  function fb_ffu (line 224) | static inline size_t
  function fb_ffs (line 231) | static inline size_t
  function fb_flu (line 241) | static inline ssize_t
  function fb_fls (line 247) | static inline ssize_t
  function JEMALLOC_ALWAYS_INLINE (line 254) | JEMALLOC_ALWAYS_INLINE bool
  function fb_srange_iter (line 284) | static inline bool
  function fb_srange_riter (line 295) | static inline bool
  function fb_urange_iter (line 303) | static inline bool
  function fb_urange_riter (line 311) | static inline bool
  function JEMALLOC_ALWAYS_INLINE (line 318) | JEMALLOC_ALWAYS_INLINE size_t
  function fb_srange_longest (line 333) | static inline size_t
  function fb_urange_longest (line 338) | static inline size_t
  function fb_bit_and (line 347) | static inline void
  function fb_bit_or (line 356) | static inline void
  function fb_bit_not (line 365) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/fxp.h
  type fxp_t (line 23) | typedef uint32_t fxp_t;
  function fxp_t (line 48) | static inline fxp_t
  function fxp_t (line 53) | static inline fxp_t
  function fxp_t (line 59) | static inline fxp_t
  function fxp_t (line 70) | static inline fxp_t
  function fxp_round_down (line 82) | static inline uint32_t
  function fxp_round_nearest (line 87) | static inline uint32_t
  function fxp_mul_frac (line 98) | static inline size_t

FILE: deps/jemalloc/include/jemalloc/internal/hash.h
  function hash_rotl_32 (line 14) | static inline uint32_t
  function hash_rotl_64 (line 19) | static inline uint64_t
  function hash_get_block_32 (line 24) | static inline uint32_t
  function hash_get_block_64 (line 37) | static inline uint64_t
  function hash_fmix_32 (line 50) | static inline uint32_t
  function hash_fmix_64 (line 61) | static inline uint64_t
  function hash_x86_32 (line 72) | static inline uint32_t
  function hash_x86_128 (line 122) | static inline void
  function hash_x64_128 (line 224) | static inline void
  function hash (line 304) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/hook.h
  type hook_alloc_e (line 51) | enum hook_alloc_e {
  type hook_alloc_t (line 68) | typedef enum hook_alloc_e hook_alloc_t;
  type hook_dalloc_e (line 70) | enum hook_dalloc_e {
  type hook_dalloc_t (line 82) | typedef enum hook_dalloc_e hook_dalloc_t;
  type hook_expand_e (line 85) | enum hook_expand_e {
  type hook_expand_t (line 90) | typedef enum hook_expand_e hook_expand_t;
  type hooks_t (line 103) | typedef struct hooks_s hooks_t;
  type hooks_s (line 104) | struct hooks_s {
  type hook_ralloc_args_t (line 130) | typedef struct hook_ralloc_args_s hook_ralloc_args_t;
  type hook_ralloc_args_s (line 131) | struct hook_ralloc_args_s {

FILE: deps/jemalloc/include/jemalloc/internal/hpa.h
  type hpa_central_t (line 10) | typedef struct hpa_central_s hpa_central_t;
  type hpa_central_s (line 11) | struct hpa_central_s {
  type hpa_shard_nonderived_stats_t (line 41) | typedef struct hpa_shard_nonderived_stats_s hpa_shard_nonderived_stats_t;
  type hpa_shard_nonderived_stats_s (line 42) | struct hpa_shard_nonderived_stats_s {
  type hpa_shard_stats_t (line 73) | typedef struct hpa_shard_stats_s hpa_shard_stats_t;
  type hpa_shard_stats_s (line 74) | struct hpa_shard_stats_s {
  type hpa_shard_t (line 79) | typedef struct hpa_shard_s hpa_shard_t;
  type hpa_shard_s (line 80) | struct hpa_shard_s {

FILE: deps/jemalloc/include/jemalloc/internal/hpa_hooks.h
  type hpa_hooks_t (line 4) | typedef struct hpa_hooks_s hpa_hooks_t;
  type hpa_hooks_s (line 5) | struct hpa_hooks_s {

FILE: deps/jemalloc/include/jemalloc/internal/hpa_opts.h
  type hpa_shard_opts_t (line 11) | typedef struct hpa_shard_opts_s hpa_shard_opts_t;
  type hpa_shard_opts_s (line 12) | struct hpa_shard_opts_s {

FILE: deps/jemalloc/include/jemalloc/internal/hpdata.h
  type hpdata_t (line 20) | typedef struct hpdata_s hpdata_t;
  type hpdata_s (line 22) | struct hpdata_s {
  function hpdata_addr_set (line 131) | static inline void
  function hpdata_age_get (line 137) | static inline uint64_t
  function hpdata_age_set (line 142) | static inline void
  function hpdata_huge_get (line 147) | static inline bool
  function hpdata_alloc_allowed_get (line 152) | static inline bool
  function hpdata_alloc_allowed_set (line 157) | static inline void
  function hpdata_in_psset_alloc_container_get (line 162) | static inline bool
  function hpdata_in_psset_alloc_container_set (line 167) | static inline void
  function hpdata_purge_allowed_get (line 173) | static inline bool
  function hpdata_purge_allowed_set (line 178) | static inline void
  function hpdata_hugify_allowed_get (line 184) | static inline bool
  function hpdata_allow_hugify (line 189) | static inline void
  function nstime_t (line 196) | static inline nstime_t
  function hpdata_disallow_hugify (line 201) | static inline void
  function hpdata_in_psset_hugify_container_get (line 206) | static inline bool
  function hpdata_in_psset_hugify_container_set (line 211) | static inline void
  function hpdata_mid_purge_get (line 217) | static inline bool
  function hpdata_mid_purge_set (line 222) | static inline void
  function hpdata_mid_hugify_get (line 228) | static inline bool
  function hpdata_mid_hugify_set (line 233) | static inline void
  function hpdata_changing_state_get (line 239) | static inline bool
  function hpdata_updating_get (line 245) | static inline bool
  function hpdata_updating_set (line 250) | static inline void
  function hpdata_in_psset_get (line 256) | static inline bool
  function hpdata_in_psset_set (line 261) | static inline void
  function hpdata_longest_free_range_get (line 267) | static inline size_t
  function hpdata_longest_free_range_set (line 272) | static inline void
  function hpdata_nactive_get (line 278) | static inline size_t
  function hpdata_ntouched_get (line 283) | static inline size_t
  function hpdata_ndirty_get (line 288) | static inline size_t
  function hpdata_nretained_get (line 293) | static inline size_t
  function hpdata_assert_empty (line 298) | static inline void
  function hpdata_consistent (line 309) | static inline bool
  function hpdata_assert_consistent (line 340) | static inline void
  function hpdata_empty (line 345) | static inline bool
  function hpdata_full (line 350) | static inline bool
  type hpdata_purge_state_t (line 369) | typedef struct hpdata_purge_state_s hpdata_purge_state_t;
  type hpdata_purge_state_s (line 370) | struct hpdata_purge_state_s {

FILE: deps/jemalloc/include/jemalloc/internal/inspect.h
  type inspect_extent_util_stats_t (line 15) | typedef struct inspect_extent_util_stats_s inspect_extent_util_stats_t;
  type inspect_extent_util_stats_s (line 16) | struct inspect_extent_util_stats_s {
  type inspect_extent_util_stats_verbose_t (line 22) | typedef struct inspect_extent_util_stats_verbose_s
  type inspect_extent_util_stats_verbose_s (line 25) | struct inspect_extent_util_stats_verbose_s {

FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_decls.h
  function isblank (line 89) | static int

FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_a.h
  function malloc_getcpu (line 11) | malloc_getcpu(void) {
  function percpu_arena_choose (line 24) | JEMALLOC_ALWAYS_INLINE unsigned
  function percpu_arena_ind_limit (line 45) | JEMALLOC_ALWAYS_INLINE unsigned
  function arena_t (line 59) | static inline arena_t *
  function JEMALLOC_ALWAYS_INLINE (line 74) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 92) | JEMALLOC_ALWAYS_INLINE tcache_t *
  function JEMALLOC_ALWAYS_INLINE (line 101) | JEMALLOC_ALWAYS_INLINE tcache_slow_t *
  function pre_reentrancy (line 110) | static inline void
  function post_reentrancy (line 117) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_b.h
  function percpu_arena_update (line 6) | static inline void
  function arena_t (line 31) | static inline arena_t *
  function arena_t (line 86) | static inline arena_t *
  function arena_t (line 91) | static inline arena_t *
  function arena_is_auto (line 96) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
  function JEMALLOC_ALWAYS_INLINE (line 29) | JEMALLOC_ALWAYS_INLINE arena_t *
  function JEMALLOC_ALWAYS_INLINE (line 36) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 43) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 62) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 68) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 88) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 94) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 100) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 105) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 123) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 128) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 136) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 175) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 198) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 205) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 224) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 235) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 257) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 342) | JEMALLOC_ALWAYS_INLINE int

FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_types.h
  type malloc_cpuid_t (line 7) | typedef int malloc_cpuid_t;
  type zero_realloc_action_e (line 10) | enum zero_realloc_action_e {
  type zero_realloc_action_t (line 18) | typedef enum zero_realloc_action_e zero_realloc_action_t;
  type malloc_init_e (line 23) | enum malloc_init_e {
  type malloc_init_t (line 29) | typedef enum malloc_init_e malloc_init_t;

FILE: deps/jemalloc/include/jemalloc/internal/lockedint.h
  type locked_u64_t (line 10) | typedef struct locked_u64_s locked_u64_t;
  type locked_u64_s (line 12) | struct locked_u64_s {
  type locked_u64_s (line 17) | struct locked_u64_s {
  type locked_zu_t (line 22) | typedef struct locked_zu_s locked_zu_t;
  type locked_zu_s (line 23) | struct locked_zu_s {
  function locked_read_u64 (line 57) | static inline uint64_t
  function locked_inc_u64 (line 67) | static inline void
  function locked_dec_u64 (line 78) | static inline void
  function locked_inc_mod_u64 (line 92) | static inline bool
  function locked_inc_u64_unsynchronized (line 126) | static inline void
  function locked_read_u64_unsynchronized (line 136) | static inline uint64_t
  function locked_init_u64_unsynchronized (line 145) | static inline void
  function locked_read_zu (line 154) | static inline size_t
  function locked_inc_zu (line 164) | static inline void
  function locked_dec_zu (line 176) | static inline void
  function locked_inc_zu_unsynchronized (line 190) | static inline void
  function locked_read_atomic_zu (line 199) | static inline size_t

FILE: deps/jemalloc/include/jemalloc/internal/log.h
  type log_var_t (line 41) | typedef struct log_var_s log_var_t;
  type log_var_s (line 42) | struct log_var_s {
  function log_impl_varargs (line 88) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/malloc_io.h
  function malloc_write_fd (line 69) | static inline ssize_t
  function malloc_read_fd (line 91) | static inline ssize_t

FILE: deps/jemalloc/include/jemalloc/internal/mutex.h
  type malloc_mutex_lock_order_t (line 11) | typedef enum {
  type malloc_mutex_t (line 21) | typedef struct malloc_mutex_s malloc_mutex_t;
  type malloc_mutex_s (line 22) | struct malloc_mutex_s {
  function malloc_mutex_lock_final (line 149) | static inline void
  function malloc_mutex_trylock_final (line 155) | static inline bool
  function mutex_owner_stats_update (line 160) | static inline void
  function malloc_mutex_trylock (line 173) | static inline bool
  function malloc_mutex_prof_merge (line 189) | static inline void
  function malloc_mutex_lock (line 212) | static inline void
  function malloc_mutex_unlock (line 225) | static inline void
  function malloc_mutex_assert_owner (line 234) | static inline void
  function malloc_mutex_assert_not_owner (line 239) | static inline void
  function malloc_mutex_prof_copy (line 244) | static inline void
  function malloc_mutex_prof_read (line 257) | static inline void
  function malloc_mutex_prof_accum (line 265) | static inline void
  function malloc_mutex_prof_max_update (line 288) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/mutex_prof.h
  type mutex_prof_global_ind_t (line 19) | typedef enum {
  type mutex_prof_arena_ind_t (line 40) | typedef enum {
  type mutex_prof_data_t (line 85) | typedef struct {

FILE: deps/jemalloc/include/jemalloc/internal/nstime.h
  type nstime_t (line 14) | typedef struct {
  type prof_time_res_e (line 52) | enum prof_time_res_e {
  type prof_time_res_t (line 56) | typedef enum prof_time_res_e prof_time_res_t;
  function JEMALLOC_ALWAYS_INLINE (line 61) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 66) | JEMALLOC_ALWAYS_INLINE bool

FILE: deps/jemalloc/include/jemalloc/internal/pa.h
  type pa_central_t (line 23) | typedef struct pa_central_s pa_central_t;
  type pa_central_s (line 24) | struct pa_central_s {
  type pa_shard_stats_t (line 39) | typedef struct pa_shard_stats_s pa_shard_stats_t;
  type pa_shard_stats_s (line 40) | struct pa_shard_stats_s {
  type pa_shard_t (line 67) | typedef struct pa_shard_s pa_shard_t;
  type pa_shard_s (line 68) | struct pa_shard_s {
  function pa_shard_dont_decay_muzzy (line 121) | static inline bool
  function ehooks_t (line 127) | static inline ehooks_t *

FILE: deps/jemalloc/include/jemalloc/internal/pac.h
  type pac_purge_eagerness_e (line 18) | enum pac_purge_eagerness_e {
  type pac_purge_eagerness_t (line 23) | typedef enum pac_purge_eagerness_e pac_purge_eagerness_t;
  type pac_decay_stats_t (line 25) | typedef struct pac_decay_stats_s pac_decay_stats_t;
  type pac_decay_stats_s (line 26) | struct pac_decay_stats_s {
  type pac_estats_t (line 35) | typedef struct pac_estats_s pac_estats_t;
  type pac_estats_s (line 36) | struct pac_estats_s {
  type pac_stats_t (line 52) | typedef struct pac_stats_s pac_stats_t;
  type pac_stats_s (line 53) | struct pac_stats_s {
  type pac_t (line 77) | typedef struct pac_s pac_t;
  type pac_s (line 78) | struct pac_s {
  function pac_mapped (line 129) | static inline size_t
  function ehooks_t (line 134) | static inline ehooks_t *

FILE: deps/jemalloc/include/jemalloc/internal/pages.h
  type thp_mode_t (line 90) | typedef enum {

FILE: deps/jemalloc/include/jemalloc/internal/pai.h
  type pai_t (line 6) | typedef struct pai_s pai_t;
  type pai_s (line 7) | struct pai_s {
  function edata_t (line 39) | static inline edata_t *
  function pai_alloc_batch (line 47) | static inline size_t
  function pai_expand (line 54) | static inline bool
  function pai_shrink (line 61) | static inline bool
  function pai_dalloc (line 68) | static inline void
  function pai_dalloc_batch (line 74) | static inline void
  function pai_time_until_deferred_work (line 80) | static inline uint64_t

FILE: deps/jemalloc/include/jemalloc/internal/peak.h
  type peak_t (line 4) | typedef struct peak_s peak_t;
  type peak_s (line 5) | struct peak_s {
  function peak_max (line 17) | static inline uint64_t
  function peak_update (line 22) | static inline void
  function peak_set_zero (line 31) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/ph.h
  type phn_link_t (line 55) | typedef struct phn_link_s phn_link_t;
  type phn_link_s (line 56) | struct phn_link_s {
  type ph_t (line 62) | typedef struct ph_s ph_t;
  type ph_s (line 63) | struct ph_s {
  function JEMALLOC_ALWAYS_INLINE (line 74) | JEMALLOC_ALWAYS_INLINE phn_link_t *
  function JEMALLOC_ALWAYS_INLINE (line 79) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 87) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 92) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 97) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 102) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 107) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 112) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 117) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 135) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 152) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 223) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 237) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 249) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 255) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 260) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 269) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 282) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 308) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 354) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 369) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/prng.h
  function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE uint32_t
  function JEMALLOC_ALWAYS_INLINE (line 39) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 44) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 64) | JEMALLOC_ALWAYS_INLINE uint32_t
  function JEMALLOC_ALWAYS_INLINE (line 75) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 86) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 102) | JEMALLOC_ALWAYS_INLINE uint32_t
  function JEMALLOC_ALWAYS_INLINE (line 126) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 147) | JEMALLOC_ALWAYS_INLINE size_t

FILE: deps/jemalloc/include/jemalloc/internal/prof_inlines.h
  function JEMALLOC_ALWAYS_INLINE (line 8) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 18) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 30) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 40) | JEMALLOC_ALWAYS_INLINE prof_tdata_t *
  function JEMALLOC_ALWAYS_INLINE (line 64) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 74) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 84) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 92) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 100) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 109) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 133) | JEMALLOC_ALWAYS_INLINE prof_tctx_t *
  function JEMALLOC_ALWAYS_INLINE (line 147) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 161) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 219) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 230) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 235) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 246) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/prof_recent.h
  type prof_recent_list_t (line 14) | typedef ql_head(prof_recent_t) prof_recent_list_t;

FILE: deps/jemalloc/include/jemalloc/internal/prof_stats.h
  type prof_stats_t (line 4) | typedef struct prof_stats_s prof_stats_t;
  type prof_stats_s (line 5) | struct prof_stats_s {

FILE: deps/jemalloc/include/jemalloc/internal/prof_structs.h
  type prof_bt_s (line 10) | struct prof_bt_s {
  type prof_unwind_data_t (line 18) | typedef struct {
  type prof_cnt_s (line 25) | struct prof_cnt_s {
  type prof_tctx_state_t (line 37) | typedef enum {
  type prof_tctx_s (line 44) | struct prof_tctx_s {
  type prof_tctx_tree_t (line 100) | typedef rb_tree(prof_tctx_t) prof_tctx_tree_t;
  type prof_info_s (line 102) | struct prof_info_s {
  type prof_gctx_s (line 111) | struct prof_gctx_s {
  type prof_gctx_tree_t (line 145) | typedef rb_tree(prof_gctx_t) prof_gctx_tree_t;
  type prof_tdata_s (line 147) | struct prof_tdata_s {
  type prof_tdata_tree_t (line 207) | typedef rb_tree(prof_tdata_t) prof_tdata_tree_t;
  type prof_recent_s (line 209) | struct prof_recent_s {

FILE: deps/jemalloc/include/jemalloc/internal/prof_types.h
  type prof_bt_t (line 4) | typedef struct prof_bt_s prof_bt_t;
  type prof_cnt_t (line 5) | typedef struct prof_cnt_s prof_cnt_t;
  type prof_tctx_t (line 6) | typedef struct prof_tctx_s prof_tctx_t;
  type prof_info_t (line 7) | typedef struct prof_info_s prof_info_t;
  type prof_gctx_t (line 8) | typedef struct prof_gctx_s prof_gctx_t;
  type prof_tdata_t (line 9) | typedef struct prof_tdata_s prof_tdata_t;
  type prof_recent_t (line 10) | typedef struct prof_recent_s prof_recent_t;

FILE: deps/jemalloc/include/jemalloc/internal/psset.h
  type psset_bin_stats_t (line 34) | typedef struct psset_bin_stats_s psset_bin_stats_t;
  type psset_bin_stats_s (line 35) | struct psset_bin_stats_s {
  type psset_stats_t (line 44) | typedef struct psset_stats_s psset_stats_t;
  type psset_stats_s (line 45) | struct psset_stats_s {
  type psset_t (line 63) | typedef struct psset_s psset_t;
  type psset_s (line 64) | struct psset_s {
  function psset_npageslabs (line 116) | static inline size_t
  function psset_nactive (line 121) | static inline size_t
  function psset_ndirty (line 126) | static inline size_t

FILE: deps/jemalloc/include/jemalloc/internal/rtree.h
  type rtree_node_elm_t (line 38) | typedef struct rtree_node_elm_s rtree_node_elm_t;
  type rtree_node_elm_s (line 39) | struct rtree_node_elm_s {
  type rtree_metadata_t (line 43) | typedef struct rtree_metadata_s rtree_metadata_t;
  type rtree_metadata_s (line 44) | struct rtree_metadata_s {
  type rtree_contents_t (line 51) | typedef struct rtree_contents_s rtree_contents_t;
  type rtree_contents_s (line 52) | struct rtree_contents_s {
  type rtree_leaf_elm_s (line 61) | struct rtree_leaf_elm_s {
  type rtree_level_t (line 87) | typedef struct rtree_level_s rtree_level_t;
  type rtree_level_s (line 88) | struct rtree_level_s {
  type rtree_t (line 98) | typedef struct rtree_s rtree_t;
  type rtree_s (line 99) | struct rtree_s {
  function rtree_leaf_maskbits (line 137) | JEMALLOC_ALWAYS_INLINE unsigned
  function JEMALLOC_ALWAYS_INLINE (line 145) | JEMALLOC_ALWAYS_INLINE uintptr_t
  function JEMALLOC_ALWAYS_INLINE (line 151) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 157) | JEMALLOC_ALWAYS_INLINE uintptr_t
  function JEMALLOC_ALWAYS_INLINE (line 179) | JEMALLOC_ALWAYS_INLINE uintptr_t
  function JEMALLOC_ALWAYS_INLINE (line 186) | JEMALLOC_ALWAYS_INLINE uintptr_t
  function JEMALLOC_ALWAYS_INLINE (line 204) | JEMALLOC_ALWAYS_INLINE rtree_contents_t
  function JEMALLOC_ALWAYS_INLINE (line 238) | JEMALLOC_ALWAYS_INLINE rtree_contents_t
  function JEMALLOC_ALWAYS_INLINE (line 266) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 281) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 296) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 308) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 337) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 356) | JEMALLOC_ALWAYS_INLINE rtree_leaf_elm_t *
  function rtree_read_independent (line 418) | static inline bool
  function rtree_contents_t (line 431) | static inline rtree_contents_t
  function rtree_metadata_t (line 440) | static inline rtree_metadata_t
  function rtree_metadata_try_read_fast (line 453) | static inline bool
  function JEMALLOC_ALWAYS_INLINE (line 472) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 503) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 510) | JEMALLOC_ALWAYS_INLINE bool
  function rtree_clear (line 524) | static inline void
  function rtree_clear_range (line 541) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/rtree_tsd.h
  type rtree_leaf_elm_t (line 44) | typedef struct rtree_leaf_elm_s rtree_leaf_elm_t;
  type rtree_ctx_cache_elm_t (line 46) | typedef struct rtree_ctx_cache_elm_s rtree_ctx_cache_elm_t;
  type rtree_ctx_cache_elm_s (line 47) | struct rtree_ctx_cache_elm_s {
  type rtree_ctx_t (line 52) | typedef struct rtree_ctx_s rtree_ctx_t;
  type rtree_ctx_s (line 53) | struct rtree_ctx_s {

FILE: deps/jemalloc/include/jemalloc/internal/safety_check.h
  function JEMALLOC_ALWAYS_INLINE (line 13) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 21) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/san.h
  function san_guard_pages_two_sided (line 39) | static inline void
  function san_unguard_pages_two_sided (line 45) | static inline void
  function san_two_side_unguarded_sz (line 51) | static inline size_t
  function san_two_side_guarded_sz (line 58) | static inline size_t
  function san_one_side_unguarded_sz (line 64) | static inline size_t
  function san_one_side_guarded_sz (line 71) | static inline size_t
  function san_guard_enabled (line 77) | static inline bool
  function san_large_extent_decide_guard (line 82) | static inline bool
  function san_slab_extent_decide_guard (line 112) | static inline bool
  function san_junk_ptr_locations (line 133) | static inline void
  function san_junk_ptr_should_slow (line 157) | static inline bool
  function san_junk_ptr (line 166) | static inline void
  function san_uaf_detection_enabled (line 180) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/san_bump.h
  type ehooks_t (line 12) | typedef struct ehooks_s ehooks_t;
  type pac_t (line 13) | typedef struct pac_s pac_t;
  type san_bump_alloc_t (line 15) | typedef struct san_bump_alloc_s san_bump_alloc_t;
  type san_bump_alloc_s (line 16) | struct san_bump_alloc_s {
  function san_bump_enabled (line 22) | static inline bool
  function san_bump_alloc_init (line 36) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/sc.h
  type sc_t (line 290) | typedef struct sc_s sc_t;
  type sc_s (line 291) | struct sc_s {
  type sc_data_t (line 315) | typedef struct sc_data_s sc_data_t;
  type sc_data_s (line 316) | struct sc_data_s {

FILE: deps/jemalloc/include/jemalloc/internal/sec.h
  type sec_stats_t (line 20) | typedef struct sec_stats_s sec_stats_t;
  type sec_stats_s (line 21) | struct sec_stats_s {
  function sec_stats_accum (line 26) | static inline void
  type sec_bin_t (line 32) | typedef struct sec_bin_s sec_bin_t;
  type sec_bin_s (line 33) | struct sec_bin_s {
  type sec_shard_t (line 62) | typedef struct sec_shard_s sec_shard_t;
  type sec_shard_s (line 63) | struct sec_shard_s {
  type sec_t (line 87) | typedef struct sec_s sec_t;
  type sec_s (line 88) | struct sec_s {

FILE: deps/jemalloc/include/jemalloc/internal/sec_opts.h
  type sec_opts_t (line 9) | typedef struct sec_opts_s sec_opts_t;
  type sec_opts_s (line 10) | struct sec_opts_s {

FILE: deps/jemalloc/include/jemalloc/internal/slab_data.h
  type slab_data_t (line 6) | typedef struct slab_data_s slab_data_t;
  type slab_data_s (line 7) | struct slab_data_s {

FILE: deps/jemalloc/include/jemalloc/internal/spin.h
  type spin_t (line 6) | typedef struct {
  function spin_cpu_spinwait (line 10) | static inline void
  function spin_adaptive (line 20) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/sz.h
  type pszind_t (line 26) | typedef unsigned pszind_t;
  type szind_t (line 29) | typedef unsigned szind_t;
  function JEMALLOC_ALWAYS_INLINE (line 56) | JEMALLOC_ALWAYS_INLINE pszind_t
  function sz_pind2sz_compute (line 107) | static inline size_t
  function sz_pind2sz_lookup (line 127) | static inline size_t
  function sz_pind2sz (line 134) | static inline size_t
  function sz_psz2u (line 140) | static inline size_t
  function szind_t (line 154) | static inline szind_t
  function JEMALLOC_ALWAYS_INLINE (line 188) | JEMALLOC_ALWAYS_INLINE szind_t
  function JEMALLOC_ALWAYS_INLINE (line 195) | JEMALLOC_ALWAYS_INLINE szind_t
  function JEMALLOC_ALWAYS_INLINE (line 202) | JEMALLOC_ALWAYS_INLINE szind_t
  function sz_index2size_compute (line 210) | static inline size_t
  function JEMALLOC_ALWAYS_INLINE (line 236) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 241) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 248) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 254) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 260) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 288) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 300) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_ALWAYS_INLINE (line 312) | JEMALLOC_ALWAYS_INLINE size_t

FILE: deps/jemalloc/include/jemalloc/internal/tcache_inlines.h
  function tcache_enabled_get (line 11) | static inline bool
  function tcache_enabled_set (line 16) | static inline void
  function JEMALLOC_ALWAYS_INLINE (line 30) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 44) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 87) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 128) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 163) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 181) | JEMALLOC_ALWAYS_INLINE tcache_t *

FILE: deps/jemalloc/include/jemalloc/internal/tcache_structs.h
  type tcache_slow_s (line 20) | struct tcache_slow_s {
  type tcache_s (line 55) | struct tcache_s {
  type tcaches_s (line 61) | struct tcaches_s {

FILE: deps/jemalloc/include/jemalloc/internal/tcache_types.h
  type tcache_slow_t (line 6) | typedef struct tcache_slow_s tcache_slow_t;
  type tcache_t (line 7) | typedef struct tcache_s tcache_t;
  type tcaches_t (line 8) | typedef struct tcaches_s tcaches_t;

FILE: deps/jemalloc/include/jemalloc/internal/thread_event.h
  type te_ctx_t (line 38) | typedef struct te_ctx_s {
  function JEMALLOC_ALWAYS_INLINE (line 113) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 120) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 128) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 133) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 138) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 143) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 148) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 154) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 161) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 167) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 178) | JEMALLOC_ALWAYS_INLINE uint64_t
  function JEMALLOC_ALWAYS_INLINE (line 183) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 197) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 204) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 238) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 268) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 273) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 291) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 296) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/ticker.h
  type ticker_t (line 14) | typedef struct ticker_s ticker_t;
  type ticker_s (line 15) | struct ticker_s {
  function ticker_init (line 20) | static inline void
  function ticker_copy (line 26) | static inline void
  function ticker_read (line 31) | static inline int32_t
  function ticker_fixup (line 59) | static bool
  function ticker_ticks (line 65) | static inline bool
  function ticker_tick (line 74) | static inline bool
  function ticker_trytick (line 83) | static inline bool
  type ticker_geom_t (line 116) | typedef struct ticker_geom_s ticker_geom_t;
  type ticker_geom_s (line 117) | struct ticker_geom_s {
  function ticker_geom_init (line 129) | static inline void
  function ticker_geom_read (line 142) | static inline int32_t
  function ticker_geom_fixup (line 152) | static bool
  function ticker_geom_ticks (line 161) | static inline bool
  function ticker_geom_tick (line 170) | static inline bool

FILE: deps/jemalloc/include/jemalloc/internal/tsd.h
  type tsd_link_t (line 56) | typedef ql_elm(tsd_t) tsd_link_t;
  type tsd_s (line 240) | struct tsd_s {
  function JEMALLOC_ALWAYS_INLINE (line 261) | JEMALLOC_ALWAYS_INLINE uint8_t
  type tsdn_s (line 277) | struct tsdn_s {
  function JEMALLOC_ALWAYS_INLINE (line 281) | JEMALLOC_ALWAYS_INLINE tsdn_t *
  function JEMALLOC_ALWAYS_INLINE (line 286) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 291) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 391) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 402) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 412) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 431) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 437) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 446) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function tsd_nominal (line 451) | static inline bool
  function JEMALLOC_ALWAYS_INLINE (line 459) | JEMALLOC_ALWAYS_INLINE tsdn_t *
  function JEMALLOC_ALWAYS_INLINE (line 468) | JEMALLOC_ALWAYS_INLINE rtree_ctx_t *
  function JEMALLOC_ALWAYS_INLINE (line 473) | JEMALLOC_ALWAYS_INLINE rtree_ctx_t *
  function tsd_state_nocleanup (line 486) | static inline bool
  function tsd_pre_reentrancy_raw (line 497) | static inline void
  function tsd_post_reentrancy_raw (line 509) | static inline void

FILE: deps/jemalloc/include/jemalloc/internal/tsd_generic.h
  type tsd_init_block_t (line 6) | typedef struct tsd_init_block_s tsd_init_block_t;
  type tsd_init_block_s (line 7) | struct tsd_init_block_s {
  type tsd_init_head_t (line 14) | typedef struct tsd_init_head_s tsd_init_head_t;
  type tsd_wrapper_t (line 16) | typedef struct {
  function JEMALLOC_ALWAYS_INLINE (line 31) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 53) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 64) | JEMALLOC_ALWAYS_INLINE tsd_wrapper_t *
  function JEMALLOC_ALWAYS_INLINE (line 101) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 121) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 140) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 149) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 154) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 160) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 172) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/tsd_malloc_thread_cleanup.h
  function JEMALLOC_ALWAYS_INLINE (line 13) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 22) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 29) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 39) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 44) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 50) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 54) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/tsd_tls.h
  function JEMALLOC_ALWAYS_INLINE (line 13) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 22) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 27) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 32) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 37) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 43) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 48) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/tsd_types.h
  type tsd_t (line 6) | typedef struct tsd_s tsd_t;
  type tsdn_t (line 7) | typedef struct tsdn_s tsdn_t;

FILE: deps/jemalloc/include/jemalloc/internal/tsd_win.h
  type tsd_wrapper_t (line 6) | typedef struct {
  function JEMALLOC_ALWAYS_INLINE (line 16) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 38) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 46) | JEMALLOC_ALWAYS_INLINE tsd_wrapper_t *
  function JEMALLOC_ALWAYS_INLINE (line 69) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 81) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 97) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 106) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 111) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 117) | JEMALLOC_ALWAYS_INLINE tsd_t *
  function JEMALLOC_ALWAYS_INLINE (line 129) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/util.h
  function UTIL_INLINE (line 46) | UTIL_INLINE void
  function UTIL_INLINE (line 56) | UTIL_INLINE int
  function JEMALLOC_ALWAYS_INLINE (line 65) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 73) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 91) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 107) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 114) | JEMALLOC_ALWAYS_INLINE void

FILE: deps/jemalloc/include/jemalloc/internal/witness.h
  type witness_rank_e (line 10) | enum witness_rank_e {
  type witness_rank_t (line 79) | typedef enum witness_rank_e witness_rank_t;
  type witness_t (line 90) | typedef struct witness_s witness_t;
  type witness_list_t (line 91) | typedef ql_head(witness_t) witness_list_t;
  type witness_s (line 95) | struct witness_s {
  type witness_tsd_t (line 122) | typedef struct witness_tsd_s witness_tsd_t;
  type witness_tsd_s (line 123) | struct witness_tsd_s {
  type witness_tsdn_t (line 134) | typedef struct witness_tsdn_s witness_tsdn_t;
  type witness_tsdn_s (line 135) | struct witness_tsdn_s {
  function JEMALLOC_ALWAYS_INLINE (line 139) | JEMALLOC_ALWAYS_INLINE witness_tsdn_t *
  function JEMALLOC_ALWAYS_INLINE (line 144) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 149) | JEMALLOC_ALWAYS_INLINE witness_tsd_t *
  function witness_owner (line 180) | static inline bool
  function witness_assert_owner (line 197) | static inline void
  function witness_assert_not_owner (line 219) | static inline void
  function witness_depth_to_rank (line 247) | static inline unsigned
  function witness_assert_depth_to_rank (line 265) | static inline void
  function witness_assert_depth (line 280) | static inline void
  function witness_assert_lockless (line 285) | static inline void
  function witness_assert_positive_depth_to_rank (line 290) | static inline void
  function witness_lock (line 305) | static inline void
  function witness_unlock (line 348) | static inline void

FILE: deps/jemalloc/include/msvc_compat/C99/stdbool.h
  type BOOL (line 11) | typedef BOOL _Bool;

FILE: deps/jemalloc/include/msvc_compat/C99/stdint.h
  type int_least8_t (line 94) | typedef int8_t    int_least8_t;
  type int_least16_t (line 95) | typedef int16_t   int_least16_t;
  type int_least32_t (line 96) | typedef int32_t   int_least32_t;
  type int_least64_t (line 97) | typedef int64_t   int_least64_t;
  type uint_least8_t (line 98) | typedef uint8_t   uint_least8_t;
  type uint_least16_t (line 99) | typedef uint16_t  uint_least16_t;
  type uint_least32_t (line 100) | typedef uint32_t  uint_least32_t;
  type uint_least64_t (line 101) | typedef uint64_t  uint_least64_t;
  type int_fast8_t (line 104) | typedef int8_t    int_fast8_t;
  type int_fast16_t (line 105) | typedef int16_t   int_fast16_t;
  type int_fast32_t (line 106) | typedef int32_t   int_fast32_t;
  type int_fast64_t (line 107) | typedef int64_t   int_fast64_t;
  type uint_fast8_t (line 108) | typedef uint8_t   uint_fast8_t;
  type uint_fast16_t (line 109) | typedef uint16_t  uint_fast16_t;
  type uint_fast32_t (line 110) | typedef uint32_t  uint_fast32_t;
  type uint_fast64_t (line 111) | typedef uint64_t  uint_fast64_t;
  type intmax_t (line 123) | typedef int64_t   intmax_t;
  type uintmax_t (line 124) | typedef uint64_t  uintmax_t;

FILE: deps/jemalloc/include/msvc_compat/strings.h
  function ffsl (line 9) | static __forceinline int ffsl(long x) {
  function ffs (line 18) | static __forceinline int ffs(int x) {
  function ffsll (line 26) | static __forceinline int ffsll(unsigned __int64 x) {

FILE: deps/jemalloc/msvc/test_threads/test_threads.cpp
  function test_threads (line 20) | int test_threads() {

FILE: deps/jemalloc/msvc/test_threads/test_threads_main.cpp
  function main (line 8) | int main(int argc, char** argv) {

FILE: deps/jemalloc/scripts/gen_run_tests.py
  function powerset (line 22) | def powerset(items):

FILE: deps/jemalloc/scripts/gen_travis.py
  class Option (line 63) | class Option(object):
    class Type (line 64) | class Type:
    method __init__ (line 71) | def __init__(self, type, value):
    method as_compiler (line 76) | def as_compiler(value):
    method as_compiler_flag (line 80) | def as_compiler_flag(value):
    method as_configure_flag (line 84) | def as_configure_flag(value):
    method as_malloc_conf (line 88) | def as_malloc_conf(value):
    method as_feature (line 92) | def as_feature(value):
    method __eq__ (line 95) | def __eq__(self, obj):
  function get_extra_cflags (line 143) | def get_extra_cflags(os, compiler):
  function format_job (line 172) | def format_job(os, arch, combination):
  function generate_unusual_combinations (line 210) | def generate_unusual_combinations(unusuals, max_unusual_opts):
  function included (line 221) | def included(combination, exclude):
  function generate_jobs (line 231) | def generate_jobs(os, arch, exclude, max_unusual_opts, unusuals=all_unus...
  function generate_linux (line 239) | def generate_linux(arch):
  function generate_macos (line 253) | def generate_macos(arch):
  function generate_windows (line 268) | def generate_windows(arch):
  function generate_freebsd (line 280) | def generate_freebsd(arch):
  function get_manual_jobs (line 294) | def get_manual_jobs():
  function main (line 309) | def main():

FILE: deps/jemalloc/src/arena.c
  function arena_basic_stats_merge (line 73) | void
  function arena_stats_merge (line 84) | void
  function arena_background_thread_inactivity_check (line 199) | static void
  function arena_handle_deferred_work (line 216) | void arena_handle_deferred_work(tsdn_t *tsdn, arena_t *arena) {
  function arena_slab_reg_alloc_batch (line 242) | static void
  function arena_large_malloc_stats_update (line 290) | static void
  function arena_large_dalloc_stats_update (line 306) | static void
  function arena_large_ralloc_stats_update (line 322) | static void
  function edata_t (line 329) | edata_t *
  function arena_extent_dalloc_large_prep (line 357) | void
  function arena_extent_ralloc_large_shrink (line 367) | void
  function arena_extent_ralloc_large_expand (line 379) | void
  function pac_purge_eagerness_t (line 396) | static pac_purge_eagerness_t
  function arena_decay_ms_set (line 407) | bool
  function arena_decay_ms_get (line 416) | ssize_t
  function arena_decay_impl (line 421) | static bool
  function arena_decay_dirty (line 456) | static bool
  function arena_decay_muzzy (line 464) | static bool
  function arena_decay (line 475) | void
  function arena_should_decay_early (line 491) | static bool
  function arena_maybe_do_deferred_work (line 530) | static void
  function arena_do_deferred_work (line 561) | void
  function arena_slab_dalloc (line 567) | void
  function arena_bin_slabs_nonfull_insert (line 576) | static void
  function arena_bin_slabs_nonfull_remove (line 585) | static void
  function edata_t (line 593) | static edata_t *
  function arena_bin_slabs_full_insert (line 606) | static void
  function arena_bin_slabs_full_remove (line 620) | static void
  function arena_bin_reset (line 628) | static void
  function arena_reset (line 659) | void
  function arena_prepare_base_deletion_sync_finish (line 711) | static void
  function arena_prepare_base_deletion_sync (line 721) | static void
  function arena_prepare_base_deletion (line 741) | static void
  function arena_destroy (line 795) | void
  function edata_t (line 830) | static edata_t *
  function arena_bin_refill_slabcur_with_fresh_slab (line 864) | static void
  function arena_bin_refill_slabcur_no_fresh_slab (line 893) | static bool
  function bin_t (line 911) | bin_t *
  function arena_cache_bin_fill_small (line 927) | void
  function arena_fill_small_fresh (line 1055) | size_t
  function arena_prof_promote (line 1236) | void
  function arena_prof_demote (line 1256) | static size_t
  function arena_dalloc_promoted (line 1269) | void
  function arena_dissociate_bin_slab (line 1294) | static void
  function arena_bin_lower_slab (line 1316) | static void
  function arena_dalloc_bin_slab_prepare (line 1343) | static void
  function arena_dalloc_bin_locked_handle_newly_empty (line 1353) | void
  function arena_dalloc_bin_locked_handle_newly_nonempty (line 1360) | void
  function arena_dalloc_bin (line 1367) | static void
  function arena_dalloc_small (line 1386) | void
  function arena_ralloc_no_move (line 1395) | bool
  function ehooks_t (line 1510) | ehooks_t *
  function extent_hooks_t (line 1515) | extent_hooks_t *
  function dss_prec_t (line 1533) | dss_prec_t
  function arena_dss_prec_set (line 1538) | bool
  function arena_dirty_decay_ms_default_get (line 1547) | ssize_t
  function arena_dirty_decay_ms_default_set (line 1552) | bool
  function arena_muzzy_decay_ms_default_get (line 1561) | ssize_t
  function arena_muzzy_decay_ms_default_set (line 1566) | bool
  function arena_retain_grow_limit_get_set (line 1575) | bool
  function arena_nthreads_get (line 1583) | unsigned
  function arena_nthreads_inc (line 1588) | void
  function arena_nthreads_dec (line 1593) | void
  function arena_t (line 1598) | arena_t *
  function arena_t (line 1710) | arena_t *
  function arena_init_huge (line 1744) | bool
  function arena_is_huge (line 1764) | bool
  function arena_boot (line 1772) | bool
  function arena_prefork0 (line 1792) | void
  function arena_prefork1 (line 1797) | void
  function arena_prefork2 (line 1804) | void
  function arena_prefork3 (line 1809) | void
  function arena_prefork4 (line 1814) | void
  function arena_prefork5 (line 1819) | void
  function arena_prefork6 (line 1824) | void
  function arena_prefork7 (line 1829) | void
  function arena_prefork8 (line 1834) | void
  function arena_postfork_parent (line 1841) | void
  function arena_postfork_child (line 1855) | void

FILE: deps/jemalloc/src/background_thread.c
  function pthread_create_wrapper_init (line 33) | static void
  function pthread_create_wrapper (line 42) | int
  function background_thread_info_init (line 71) | static void
  function set_current_thread_affinity (line 81) | static inline bool
  function background_thread_sleep (line 119) | static void
  function background_thread_pause_check (line 173) | static bool
  function background_work_sleep_once (line 187) | static inline void
  function background_threads_disable_single (line 232) | static bool
  function background_thread_create_signals_masked (line 273) | static int
  function check_background_thread_creation (line 305) | static bool
  function background_thread0_work (line 355) | static void
  function background_work (line 404) | static void
  function background_thread_init (line 451) | static void
  function background_thread_create_locked (line 459) | static bool
  function background_thread_create (line 514) | bool
  function background_threads_enable (line 526) | bool
  function background_threads_disable (line 573) | bool
  function background_thread_is_started (line 596) | bool
  function background_thread_wakeup_early (line 601) | void
  function background_thread_prefork0 (line 616) | void
  function background_thread_prefork1 (line 622) | void
  function background_thread_postfork_parent (line 629) | void
  function background_thread_postfork_child (line 638) | void
  function background_thread_stats_read (line 665) | bool
  function pthread_create_fptr_init (line 713) | static bool
  function background_thread_ctl_init (line 748) | void
  function background_thread_boot0 (line 759) | bool
  function background_thread_boot1 (line 775) | bool

FILE: deps/jemalloc/src/base.c
  function metadata_thp_madvise (line 33) | static inline bool
  function base_unmap (line 61) | static void
  function base_edata_init (line 113) | static void
  function base_get_num_blocks (line 124) | static size_t
  function base_auto_thp_switch (line 138) | static void
  function base_extent_bump_alloc_post (line 192) | static void
  function base_block_t (line 242) | static base_block_t *
  function edata_t (line 302) | static edata_t *
  function base_t (line 339) | base_t *
  function base_t (line 344) | base_t *
  function base_delete (line 404) | void
  function ehooks_t (line 416) | ehooks_t *
  function ehooks_t (line 421) | ehooks_t *
  function extent_hooks_t (line 426) | extent_hooks_t *
  function edata_t (line 482) | edata_t *
  function base_stats_get (line 494) | void
  function base_prefork (line 509) | void
  function base_postfork_parent (line 514) | void
  function base_postfork_child (line 519) | void
  function base_boot (line 524) | bool

FILE: deps/jemalloc/src/bin.c
  function bin_update_shard_size (line 9) | bool
  function bin_shard_sizes_boot (line 33) | void
  function bin_init (line 41) | bool
  function bin_prefork (line 56) | void
  function bin_postfork_parent (line 61) | void
  function bin_postfork_child (line 66) | void

FILE: deps/jemalloc/src/bin_info.c
  function bin_infos_init (line 8) | static void
  function bin_info_boot (line 26) | void

FILE: deps/jemalloc/src/bitmap.c
  function bitmap_info_init (line 10) | void
  function bitmap_info_ngroups (line 38) | static size_t
  function bitmap_init (line 43) | void
  function bitmap_info_init (line 84) | void
  function bitmap_info_ngroups (line 93) | static size_t
  function bitmap_init (line 98) | void
  function bitmap_size (line 117) | size_t

FILE: deps/jemalloc/src/buf_writer.c
  function buf_writer_free_internal_buf (line 20) | static void
  function buf_writer_assert (line 27) | static void
  function buf_writer_init (line 40) | bool
  function buf_writer_flush (line 69) | void
  function buf_writer_cb (line 81) | void
  function buf_writer_terminate (line 104) | void
  function buf_writer_pipe (line 113) | void

FILE: deps/jemalloc/src/cache_bin.c
  function cache_bin_info_init (line 8) | void
  function cache_bin_info_compute_alloc (line 17) | void
  function cache_bin_preincrement (line 40) | void
  function cache_bin_postincrement (line 58) | void
  function cache_bin_init (line 66) | void
  function cache_bin_still_zero_initialized (line 96) | bool

FILE: deps/jemalloc/src/ckh.c
  function ckh_bucket_search (line 61) | static size_t
  function ckh_isearch (line 79) | static size_t
  function ckh_try_bucket_insert (line 100) | static bool
  function ckh_evict_reloc_insert (line 132) | static bool
  function ckh_try_insert (line 203) | static bool
  function ckh_rebuild (line 233) | static bool
  function ckh_grow (line 255) | static bool
  function ckh_shrink (line 310) | static void
  function ckh_new (line 358) | bool
  function ckh_delete (line 415) | void
  function ckh_count (line 437) | size_t
  function ckh_iter (line 444) | bool
  function ckh_insert (line 465) | bool
  function ckh_remove (line 488) | bool
  function ckh_search (line 521) | bool
  function ckh_string_hash (line 541) | void
  function ckh_string_keycomp (line 546) | bool
  function ckh_pointer_hash (line 554) | void
  function ckh_pointer_keycomp (line 566) | bool

FILE: deps/jemalloc/src/counter.c
  function counter_accum_init (line 6) | bool
  function counter_prefork (line 17) | void
  function counter_postfork_parent (line 22) | void
  function counter_postfork_child (line 27) | void

FILE: deps/jemalloc/src/ctl.c
  function ctl_named_node_t (line 36) | static const ctl_named_node_t *
  function ctl_named_node_t (line 41) | static const ctl_named_node_t *
  function ctl_indexed_node_t (line 48) | static const ctl_indexed_node_t *
  function MUTEX_PROF_GLOBAL_MUTEXES (line 828) | MUTEX_PROF_GLOBAL_MUTEXES
  function thread_peak_read_ctl (line 2328) | static int
  function thread_peak_reset_ctl (line 2345) | static int
  function thread_prof_name_ctl (line 2360) | static int
  function thread_prof_active_ctl (line 2392) | static int
  function thread_idle_ctl (line 2425) | static int
  function tcache_create_ctl (line 2460) | static int
  function tcache_flush_ctl (line 2479) | static int
  function tcache_destroy_ctl (line 2494) | static int
  function arena_i_initialized_ctl (line 2511) | static int
  function arena_i_decay (line 2533) | static void
  function arena_i_decay_ctl (line 2580) | static int
  function arena_i_purge_ctl (line 2595) | static int
  function arena_i_reset_destroy_helper (line 2610) | static int
  function arena_reset_prepare_background_thread (line 2630) | static void
  function arena_reset_finish_background_thread (line 2646) | static void
  function arena_i_reset_ctl (line 2661) | static int
  function arena_i_destroy_ctl (line 2681) | static int
  function arena_i_dss_ctl (line 2726) | static int
  function arena_i_oversize_threshold_ctl (line 2787) | static int
  function arena_i_decay_ms_ctl_impl (line 2819) | static int
  function arena_i_dirty_decay_ms_ctl (line 2867) | static int
  function arena_i_muzzy_decay_ms_ctl (line 2874) | static int
  function arena_i_extent_hooks_ctl (line 2881) | static int
  function arena_i_retain_grow_limit_ctl (line 2941) | static int
  function ctl_named_node_t (line 2978) | static const ctl_named_node_t *
  function arenas_narenas_ctl (line 3004) | static int
  function arenas_decay_ms_ctl_impl (line 3021) | static int
  function arenas_dirty_decay_ms_ctl (line 3049) | static int
  function arenas_muzzy_decay_ms_ctl (line 3056) | static int
  function ctl_named_node_t (line 3072) | static const ctl_named_node_t *
  function ctl_named_node_t (line 3084) | static const ctl_named_node_t *
  function arenas_create_ctl (line 3093) | static int
  function experimental_arenas_create_ext_ctl (line 3116) | static int
  function arenas_lookup_ctl (line 3140) | static int
  function prof_thread_active_init_ctl (line 3175) | static int
  function prof_active_ctl (line 3208) | static int
  function prof_dump_ctl (line 3246) | static int
  function prof_gdump_ctl (line 3269) | static int
  function prof_prefix_ctl (line 3299) | static int
  function prof_reset_ctl (line 3319) | static int
  function prof_log_start_ctl (line 3345) | static int
  function prof_log_stop_ctl (line 3369) | static int
  function experimental_hooks_prof_backtrace_ctl (line 3383) | static int
  function experimental_hooks_prof_dump_ctl (line 3415) | static int
  function experimental_hooks_safety_check_abort_ctl (line 3444) | static int
  function stats_mutexes_reset_ctl (line 3616) | static int
  function ctl_named_node_t (line 3695) | static const ctl_named_node_t *
  function ctl_named_node_t (line 3716) | static const ctl_named_node_t *
  function ctl_named_node_t (line 3738) | static const ctl_named_node_t *
  function ctl_named_node_t (line 3814) | static const ctl_named_node_t *
  function ctl_arenas_i_verify (line 3823) | static bool
  function ctl_named_node_t (line 3833) | static const ctl_named_node_t *
  function experimental_hooks_install_ctl (line 3850) | static int
  function experimental_hooks_remove_ctl (line 3878) | static int
  function experimental_thread_activity_callback_ctl (line 3895) | static int
  function experimental_utilization_query_ctl (line 3988) | static int
  function experimental_utilization_batch_query_ctl (line 4113) | static int
  function ctl_named_node_t (line 4143) | static const ctl_named_node_t *
  function experimental_arenas_i_pactivep_ctl (line 4159) | static int
  function experimental_prof_recent_alloc_max_ctl (line 4196) | static int
  type write_cb_packet_t (line 4229) | typedef struct write_cb_packet_s write_cb_packet_t;
  type write_cb_packet_s (line 4230) | struct write_cb_packet_s {
  function experimental_prof_recent_alloc_dump_ctl (line 4235) | static int
  type batch_alloc_packet_t (line 4260) | typedef struct batch_alloc_packet_s batch_alloc_packet_t;
  type batch_alloc_packet_s (line 4261) | struct batch_alloc_packet_s {
  function experimental_batch_alloc_ctl (line 4268) | static int
  function prof_stats_bins_i_live_ctl (line 4288) | static int
  function prof_stats_bins_i_accum_ctl (line 4314) | static int
  function ctl_named_node_t (line 4340) | static const ctl_named_node_t *
  function prof_stats_lextents_i_live_ctl (line 4352) | static int
  function prof_stats_lextents_i_accum_ctl (line 4378) | static int
  function ctl_named_node_t (line 4404) | static const ctl_named_node_t *

FILE: deps/jemalloc/src/decay.c
  function decay_deadline_init (line 17) | void
  function decay_reinit (line 30) | void
  function decay_init (line 46) | bool
  function decay_ms_valid (line 63) | bool
  function decay_maybe_update_time (line 75) | static void
  function decay_backlog_npages_limit (line 96) | static size_t
  function decay_backlog_update (line 117) | static void
  function decay_deadline_reached (line 152) | static inline bool
  function decay_npages_purge_in (line 157) | uint64_t
  function decay_maybe_advance_epoch (line 176) | bool
  function decay_npurge_after_interval (line 226) | static inline size_t
  function decay_ns_until_purge (line 241) | uint64_t decay_ns_until_purge(decay_t *decay, size_t npages_current,

FILE: deps/jemalloc/src/div.c
  function div_init (line 29) | void

FILE: deps/jemalloc/src/ecache.c
  function ecache_init (line 6) | bool
  function ecache_prefork (line 22) | void
  function ecache_postfork_parent (line 27) | void
  function ecache_postfork_child (line 32) | void

FILE: deps/jemalloc/src/edata_cache.c
  function edata_cache_init (line 4) | bool
  function edata_t (line 21) | edata_t *
  function edata_cache_put (line 35) | void
  function edata_cache_prefork (line 43) | void
  function edata_cache_postfork_parent (line 48) | void
  function edata_cache_postfork_child (line 53) | void
  function edata_cache_fast_init (line 58) | void
  function edata_cache_fast_try_fill_from_fallback (line 65) | static void
  function edata_t (line 81) | edata_t *
  function edata_cache_fast_flush_all (line 111) | static void
  function edata_cache_fast_put (line 132) | void
  function edata_cache_fast_disable (line 150) | void

FILE: deps/jemalloc/src/ehooks.c
  function ehooks_init (line 7) | void
  function ehooks_default_dalloc_impl (line 74) | bool
  function ehooks_default_dalloc (line 82) | static bool
  function ehooks_default_destroy_impl (line 88) | void
  function ehooks_default_destroy (line 95) | static void
  function ehooks_default_commit_impl (line 101) | bool
  function ehooks_default_commit (line 107) | static bool
  function ehooks_default_decommit_impl (line 113) | bool
  function ehooks_default_decommit (line 119) | static bool
  function ehooks_default_purge_lazy_impl (line 126) | bool
  function ehooks_default_purge_lazy (line 132) | static bool
  function ehooks_default_purge_forced_impl (line 144) | bool
  function ehooks_default_purge_forced (line 150) | static bool
  function ehooks_default_split_impl (line 161) | bool
  function ehooks_default_split (line 175) | static bool
  function ehooks_default_merge_impl (line 181) | bool
  function ehooks_default_merge (line 222) | bool
  function ehooks_default_zero_impl (line 230) | void
  function ehooks_default_guard_impl (line 247) | void
  function ehooks_default_unguard_impl (line 252) | void

FILE: deps/jemalloc/src/emap.c
  type emap_lock_result_e (line 6) | enum emap_lock_result_e {
  type emap_lock_result_t (line 11) | typedef enum emap_lock_result_e emap_lock_result_t;
  function emap_init (line 13) | bool
  function emap_update_edata_state (line 18) | void
  function edata_t (line 41) | static inline edata_t *
  function edata_t (line 96) | edata_t *
  function edata_t (line 103) | edata_t *
  function emap_release_edata (line 111) | void
  function emap_rtree_leaf_elms_lookup (line 120) | static bool
  function emap_rtree_write_acquired (line 141) | static void
  function emap_register_boundary (line 157) | bool
  function emap_register_interior (line 178) | void
  function emap_deregister_boundary (line 215) | void
  function emap_deregister_interior (line 235) | void
  function emap_remap (line 247) | void
  function emap_split_prepare (line 283) | bool
  function emap_split_commit (line 309) | void
  function emap_merge_prepare (line 326) | void
  function emap_merge_commit (line 336) | void
  function emap_do_assert_mapped (line 364) | void
  function emap_do_assert_not_mapped (line 375) | void

FILE: deps/jemalloc/src/eset.c
  function eset_bin_init (line 8) | static void
  function eset_bin_stats_init (line 17) | static void
  function eset_init (line 23) | void
  function eset_npages_get (line 34) | size_t
  function eset_nextents_get (line 39) | size_t
  function eset_nbytes_get (line 44) | size_t
  function eset_stats_add (line 49) | static void
  function eset_stats_sub (line 60) | static void
  function eset_insert (line 71) | void
  function eset_remove (line 113) | void
  function edata_t (line 162) | static edata_t *
  function edata_t (line 205) | static edata_t *
  function edata_t (line 261) | edata_t *

FILE: deps/jemalloc/src/exp_grow.c
  function exp_grow_init (line 4) | void

FILE: deps/jemalloc/src/extent.c
  function extent_sn_next (line 49) | size_t
  function extent_may_force_decay (line 54) | static inline bool
  function extent_try_delayed_coalesce (line 60) | static bool
  function edata_t (line 77) | edata_t *
  function edata_t (line 94) | edata_t *
  function ecache_dalloc (line 135) | void
  function edata_t (line 150) | edata_t *
  function extents_abandon_vm (line 225) | static void
  function extent_deactivate_locked_impl (line 247) | static void
  function extent_deactivate_locked (line 259) | static void
  function extent_deactivate_check_state_locked (line 266) | static void
  function extent_activate_locked (line 273) | static void
  function extent_gdump_add (line 284) | void
  function extent_gdump_sub (line 310) | static void
  function extent_register_impl (line 321) | static bool
  function extent_register (line 340) | static bool
  function extent_register_no_gdump_add (line 345) | static bool
  function extent_reregister (line 350) | static void
  function extent_deregister_impl (line 359) | static void
  function extent_deregister (line 369) | static void
  function extent_deregister_no_gdump_sub (line 374) | static void
  function edata_t (line 384) | static edata_t *
  type extent_split_interior_result_t (line 456) | typedef enum {
  function extent_split_interior_result_t (line 475) | static extent_split_interior_result_t
  function edata_t (line 531) | static edata_t *
  function edata_t (line 595) | static edata_t *
  function edata_t (line 643) | static edata_t *
  function edata_t (line 773) | static edata_t *
  function extent_coalesce (line 802) | static bool
  function edata_t (line 819) | static edata_t *
  function edata_t (line 874) | static edata_t *
  function edata_t (line 881) | static edata_t *
  function extent_maximally_purge (line 889) | static void
  function extent_record (line 914) | void
  function extent_dalloc_gap (line 955) | void
  function extent_dalloc_wrapper_try (line 968) | static bool
  function edata_t (line 991) | edata_t *
  function extent_dalloc_wrapper (line 1027) | void
  function extent_destroy_wrapper (line 1079) | void
  function extent_commit_impl (line 1103) | static bool
  function extent_commit_wrapper (line 1114) | bool
  function extent_decommit_wrapper (line 1121) | bool
  function extent_purge_lazy_impl (line 1132) | static bool
  function extent_purge_lazy_wrapper (line 1142) | bool
  function extent_purge_forced_impl (line 1149) | static bool
  function extent_purge_forced_wrapper (line 1159) | bool
  function edata_t (line 1173) | static edata_t *
  function edata_t (line 1234) | edata_t *
  function extent_merge_impl (line 1241) | static bool
  function extent_merge_wrapper (line 1290) | bool
  function extent_commit_zero (line 1297) | bool
  function extent_boot (line 1317) | bool

FILE: deps/jemalloc/src/extent_dss.c
  function dss_prec_t (line 50) | dss_prec_t
  function extent_dss_prec_set (line 61) | bool
  function extent_dss_extending_start (line 70) | static void
  function extent_dss_extending_finish (line 83) | static void
  function extent_in_dss_helper (line 237) | static bool
  function extent_in_dss (line 243) | bool
  function extent_dss_mergeable (line 251) | bool
  function extent_dss_boot (line 267) | void

FILE: deps/jemalloc/src/extent_mmap.c
  function extent_dalloc_mmap (line 35) | bool

FILE: deps/jemalloc/src/fxp.c
  function fxp_isdigit (line 6) | static bool
  function fxp_parse (line 11) | bool
  function fxp_print (line 97) | void

FILE: deps/jemalloc/src/hook.c
  type hooks_internal_t (line 9) | typedef struct hooks_internal_s hooks_internal_t;
  type hooks_internal_s (line 10) | struct hooks_internal_s {
  function hook_boot (line 21) | bool
  function hook_remove_locked (line 58) | static void
  function hook_remove (line 72) | void
  function hook_invoke_alloc (line 153) | void
  function hook_invoke_dalloc (line 169) | void
  function hook_invoke_expand (line 182) | void

FILE: deps/jemalloc/src/hpa.c
  function hpa_supported (line 26) | bool
  function hpa_do_consistency_checks (line 56) | static void
  function hpa_central_init (line 61) | bool
  function hpdata_t (line 84) | static hpdata_t *
  function hpdata_t (line 90) | hpdata_t *
  function hpa_shard_init (line 177) | bool
  function hpa_shard_nonderived_stats_accum (line 238) | static void
  function hpa_shard_stats_accum (line 247) | void
  function hpa_shard_stats_merge (line 254) | void
  function hpa_good_hugification_candidate (line 267) | static bool
  function hpa_adjusted_ndirty (line 278) | static size_t
  function hpa_ndirty_max (line 284) | static size_t
  function hpa_hugify_blocked_by_ndirty (line 294) | static bool
  function hpa_should_purge (line 305) | static bool
  function hpa_update_purge_hugify_eligibility (line 317) | static void
  function hpa_shard_has_deferred_work (line 372) | static bool
  function hpa_try_purge (line 380) | static bool
  function hpa_try_hugify (line 465) | static bool
  function hpa_shard_maybe_do_deferred_work (line 519) | static void
  function edata_t (line 556) | static edata_t *
  function hpa_try_alloc_batch_no_grow (line 625) | static size_t
  function hpa_alloc_batch_psset (line 646) | static size_t
  function hpa_shard_t (line 708) | static hpa_shard_t *
  function hpa_alloc_batch (line 717) | static size_t
  function edata_t (line 759) | static edata_t *
  function hpa_expand (line 784) | static bool
  function hpa_shrink (line 791) | static bool
  function hpa_dalloc_prepare_unlocked (line 798) | static void
  function hpa_dalloc_locked (line 823) | static void
  function hpa_dalloc_batch (line 848) | static void
  function hpa_dalloc (line 871) | static void
  function hpa_time_until_deferred_work (line 886) | static uint64_t
  function hpa_shard_disable (line 942) | void
  function hpa_shard_assert_stats_empty (line 951) | static void
  function hpa_assert_empty (line 957) | static void
  function hpa_shard_destroy (line 969) | void
  function hpa_shard_set_deferral_allowed (line 992) | void
  function hpa_shard_do_deferred_work (line 1007) | void
  function hpa_shard_prefork3 (line 1016) | void
  function hpa_shard_prefork4 (line 1023) | void
  function hpa_shard_postfork_parent (line 1030) | void
  function hpa_shard_postfork_child (line 1038) | void

FILE: deps/jemalloc/src/hpa_hooks.c
  function hpa_hooks_unmap (line 30) | static void
  function hpa_hooks_purge (line 35) | static void
  function hpa_hooks_hugify (line 40) | static void
  function hpa_hooks_dehugify (line 46) | static void
  function hpa_hooks_curtime (line 52) | static void
  function hpa_hooks_ms_since (line 60) | static uint64_t

FILE: deps/jemalloc/src/hpdata.c
  function hpdata_age_comp (line 6) | static int
  function hpdata_init (line 18) | ph_gen(, hpdata_age_heap, hpdata_t, age_link, hpdata_age_comp)
  function hpdata_unreserve (line 136) | void
  function hpdata_purge_begin (line 166) | size_t
  function hpdata_purge_next (line 258) | bool
  function hpdata_purge_end (line 290) | void
  function hpdata_hugify (line 311) | void
  function hpdata_dehugify (line 320) | void

FILE: deps/jemalloc/src/inspect.c
  function inspect_extent_util_stats_get (line 4) | void
  function inspect_extent_util_stats_verbose_get (line 27) | void

FILE: deps/jemalloc/src/jemalloc.c
  function default_junk_alloc (line 137) | static void default_junk_alloc(void *ptr, size_t usize) {
  function default_junk_free (line 141) | static void default_junk_free(void *ptr, size_t usize) {
  function WINAPI (line 220) | WINAPI
  type malloc_utrace_t (line 249) | typedef struct {
  function JEMALLOC_ALWAYS_INLINE (line 288) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 296) | JEMALLOC_ALWAYS_INLINE bool
  function a0idalloc (line 319) | static void
  function a0dalloc (line 329) | void
  function bootstrap_free (line 362) | void
  function arena_set (line 371) | void
  function narenas_total_set (line 376) | static void
  function narenas_total_inc (line 381) | static void
  function narenas_total_get (line 386) | unsigned
  function arena_t (line 392) | static arena_t *
  function arena_new_create_background_thread (line 420) | static void
  function arena_t (line 438) | arena_t *
  function arena_bind (line 451) | static void
  function arena_migrate (line 471) | void
  function arena_unbind (line 487) | static void
  function arena_t (line 502) | arena_t *
  function iarena_cleanup (line 615) | void
  function arena_cleanup (line 625) | void
  function stats_print_atexit (line 635) | static void
  function JEMALLOC_ALWAYS_INLINE (line 674) | JEMALLOC_ALWAYS_INLINE void
  function malloc_ncpus (line 716) | static unsigned
  function malloc_cpu_count_is_deterministic (line 761) | static bool
  function init_opt_stats_opts (line 792) | static void
  function malloc_conf_multi_sizes_next (line 818) | static bool
  function malloc_conf_next (line 861) | static bool
  function malloc_abort_invalid_conf (line 939) | static void
  function malloc_conf_error (line 947) | static void
  function malloc_slow_flag_init (line 961) | static void
  function malloc_conf_init_helper (line 1065) | static void
  function malloc_conf_init_check_deps (line 1732) | static bool
  function malloc_conf_init (line 1743) | static void
  function malloc_init_hard_needed (line 1763) | static bool
  function malloc_init_hard_a0_locked (line 1789) | static bool
  function malloc_init_hard_a0 (line 1913) | static bool
  function malloc_init_hard_recursible (line 1924) | static bool
  function malloc_narenas_default (line 1974) | static unsigned
  function percpu_arena_mode_t (line 1994) | static percpu_arena_mode_t
  function malloc_init_narenas (line 2006) | static bool
  function malloc_init_percpu (line 2082) | static void
  function malloc_init_hard_finish (line 2087) | static bool
  function malloc_init_hard_cleanup (line 2099) | static void
  function malloc_init_hard (line 2111) | static bool
  type static_opts_t (line 2195) | typedef struct static_opts_s static_opts_t;
  type static_opts_s (line 2196) | struct static_opts_s {
  function JEMALLOC_ALWAYS_INLINE (line 2243) | JEMALLOC_ALWAYS_INLINE void
  type dynamic_opts_t (line 2266) | typedef struct dynamic_opts_s dynamic_opts_t;
  type dynamic_opts_s (line 2267) | struct dynamic_opts_s {
  function JEMALLOC_ALWAYS_INLINE (line 2278) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 2294) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2321) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2330) | JEMALLOC_ALWAYS_INLINE tcache_t *
  function JEMALLOC_ALWAYS_INLINE (line 2361) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2380) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 2402) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 2440) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2478) | JEMALLOC_ALWAYS_INLINE int
  function JEMALLOC_ALWAYS_INLINE (line 2656) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2674) | JEMALLOC_ALWAYS_INLINE int
  function JEMALLOC_NOINLINE (line 2698) | JEMALLOC_NOINLINE
  function JEMALLOC_ALWAYS_INLINE (line 2873) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 2910) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 2933) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_NOINLINE (line 3005) | JEMALLOC_NOINLINE
  function JEMALLOC_ALWAYS_INLINE (line 3039) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 3075) | JEMALLOC_ALWAYS_INLINE
  function je_free_internal (line 3170) | static inline void je_free_internal(void *ptr, size_t *usize) {
  function JEMALLOC_NOTHROW (line 3180) | JEMALLOC_NOTHROW
  function mallocx_tcache_get (line 3333) | JEMALLOC_ALWAYS_INLINE unsigned
  function mallocx_arena_get (line 3344) | JEMALLOC_ALWAYS_INLINE unsigned
  type smallocx_return_t (line 3359) | typedef struct {
  function JEMALLOC_NOTHROW (line 3365) | JEMALLOC_NOTHROW
  function JEMALLOC_ALWAYS_INLINE (line 3480) | JEMALLOC_ALWAYS_INLINE void *
  function JEMALLOC_ALWAYS_INLINE (line 3692) | JEMALLOC_ALWAYS_INLINE size_t
  function ixallocx_prof_sample (line 3705) | static size_t
  function JEMALLOC_ALWAYS_INLINE (line 3717) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_NOTHROW (line 3780) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 3896) | JEMALLOC_NOTHROW
  function JEMALLOC_ALWAYS_INLINE (line 3925) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_NOINLINE (line 3935) | JEMALLOC_NOINLINE void
  function JEMALLOC_NOTHROW (line 3961) | JEMALLOC_NOTHROW
  function je_sdallocx_noflags (line 3973) | void JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 3985) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4012) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4034) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4054) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4076) | JEMALLOC_NOTHROW
  function JEMALLOC_ALWAYS_INLINE (line 4101) | JEMALLOC_ALWAYS_INLINE size_t
  function JEMALLOC_NOTHROW (line 4124) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4135) | JEMALLOC_NOTHROW
  function batch_alloc_prof_sample_assert (line 4146) | static void
  function batch_alloc (line 4159) | size_t
  function jemalloc_constructor (line 4347) | JEMALLOC_ATTR(constructor)
  function jemalloc_prefork (line 4355) | void
  function jemalloc_postfork_parent (line 4434) | void
  function jemalloc_postfork_child (line 4474) | void
  function JEMALLOC_NOTHROW (line 4509) | JEMALLOC_NOTHROW
  function JEMALLOC_NOTHROW (line 4536) | JEMALLOC_NOTHROW

FILE: deps/jemalloc/src/jemalloc_cpp.cpp
  function JEMALLOC_NOINLINE (line 56) | JEMALLOC_NOINLINE
  function JEMALLOC_NOINLINE (line 95) | JEMALLOC_NOINLINE
  function JEMALLOC_ALWAYS_INLINE (line 106) | JEMALLOC_ALWAYS_INLINE
  function JEMALLOC_ALWAYS_INLINE (line 135) | JEMALLOC_ALWAYS_INLINE
  function JEMALLOC_ALWAYS_INLINE (line 189) | JEMALLOC_ALWAYS_INLINE
  function JEMALLOC_ALWAYS_INLINE (line 212) | JEMALLOC_ALWAYS_INLINE

FILE: deps/jemalloc/src/large.c
  function large_ralloc_no_move_shrink (line 54) | static bool
  function large_ralloc_no_move_expand (line 82) | static bool
  function large_ralloc_no_move (line 129) | bool
  function large_dalloc_prep_impl (line 230) | static void
  function large_dalloc_finish_impl (line 250) | static void
  function large_dalloc_prep_locked (line 259) | void
  function large_dalloc_finish (line 264) | void
  function large_dalloc (line 269) | void
  function large_salloc (line 277) | size_t
  function large_prof_info_get (line 282) | void
  function large_prof_tctx_set (line 304) | static void
  function large_prof_tctx_reset (line 309) | void
  function large_prof_info_set (line 314) | void

FILE: deps/jemalloc/src/log.c
  function log_var_matches_segment (line 21) | static bool
  function log_var_update_state (line 43) | unsigned

FILE: deps/jemalloc/src/malloc_io.c
  function wrtmessage (line 69) | void
  function malloc_write (line 80) | void
  function buferror (line 93) | int
  function uintmax_t (line 111) | uintmax_t
  function JEMALLOC_COLD (line 324) | JEMALLOC_COLD
  function malloc_cprintf (line 669) | void
  function malloc_printf (line 680) | void

FILE: deps/jemalloc/src/mutex.c
  function JEMALLOC_EXPORT (line 36) | JEMALLOC_EXPORT int
  function malloc_mutex_lock_slow (line 51) | void
  function mutex_prof_data_init (line 109) | static void
  function malloc_mutex_prof_data_reset (line 117) | void
  function mutex_addr_comp (line 123) | static int
  function malloc_mutex_init (line 139) | bool
  function malloc_mutex_prefork (line 189) | void
  function malloc_mutex_postfork_parent (line 194) | void
  function malloc_mutex_postfork_child (line 199) | void
  function malloc_mutex_boot (line 215) | bool

FILE: deps/jemalloc/src/nstime.c
  function nstime_set_initialized (line 11) | static void
  function nstime_assert_initialized (line 18) | static void
  function nstime_pair_assert_initialized (line 30) | static void
  function nstime_initialize_operand (line 36) | static void
  function nstime_init (line 47) | void
  function nstime_init2 (line 53) | void
  function nstime_ns (line 59) | uint64_t
  function nstime_msec (line 65) | uint64_t
  function nstime_sec (line 71) | uint64_t
  function nstime_nsec (line 77) | uint64_t
  function nstime_copy (line 83) | void
  function nstime_compare (line 91) | int
  function nstime_add (line 97) | void
  function nstime_iadd (line 106) | void
  function nstime_subtract (line 115) | void
  function nstime_isubtract (line 124) | void
  function nstime_imultiply (line 133) | void
  function nstime_idivide (line 143) | void
  function nstime_divide (line 152) | uint64_t
  function nstime_ns_since (line 162) | uint64_t
  function nstime_get (line 176) | static void
  function nstime_get (line 188) | static void
  function nstime_get (line 197) | static void
  function nstime_get (line 206) | static void
  function nstime_get (line 212) | static void
  function nstime_monotonic_impl (line 221) | static bool
  function nstime_get_realtime (line 237) | static void
  function nstime_prof_update_impl (line 249) | static void
  function nstime_update_impl (line 263) | static void
  function nstime_init_update (line 277) | void
  function nstime_prof_init_update (line 283) | void

FILE: deps/jemalloc/src/pa.c
  function pa_nactive_add (line 7) | static void
  function pa_nactive_sub (line 12) | static void
  function pa_central_init (line 18) | bool
  function pa_shard_init (line 31) | bool
  function pa_shard_enable_hpa (line 67) | bool
  function pa_shard_disable_hpa (line 84) | void
  function pa_shard_reset (line 93) | void
  function pa_shard_uses_hpa (line 101) | static bool
  function pa_shard_destroy (line 106) | void
  function pai_t (line 115) | static pai_t *
  function edata_t (line 121) | edata_t *
  function pa_expand (line 156) | bool
  function pa_shrink (line 181) | bool
  function pa_dalloc (line 205) | void
  function pa_shard_retain_grow_limit_get_set (line 223) | bool
  function pa_decay_ms_set (line 230) | bool
  function pa_decay_ms_get (line 236) | ssize_t
  function pa_shard_set_deferral_allowed (line 241) | void
  function pa_shard_do_deferred_work (line 250) | void
  function pa_shard_time_until_deferred_work (line 262) | uint64_t

FILE: deps/jemalloc/src/pa_extra.c
  function pa_shard_prefork0 (line 11) | void
  function pa_shard_prefork2 (line 17) | void
  function pa_shard_prefork3 (line 24) | void
  function pa_shard_prefork4 (line 32) | void
  function pa_shard_prefork5 (line 42) | void
  function pa_shard_postfork_parent (line 47) | void
  function pa_shard_postfork_child (line 62) | void
  function pa_shard_basic_stats_merge (line 77) | void
  function pa_shard_stats_merge (line 85) | void
  function pa_shard_mtx_stats_read_single (line 158) | static void
  function pa_shard_mtx_stats_read (line 166) | void

FILE: deps/jemalloc/src/pac.c
  function pac_decay_data_get (line 18) | static inline void
  function pac_init (line 37) | bool
  function pac_may_have_muzzy (line 106) | static inline bool
  function edata_t (line 111) | static edata_t *
  function edata_t (line 136) | static edata_t *
  function edata_t (line 163) | static edata_t *
  function pac_expand_impl (line 190) | static bool
  function pac_shrink_impl (line 228) | static bool
  function pac_dalloc_impl (line 250) | static void
  function pac_ns_until_purge (line 282) | static inline uint64_t
  function pac_time_until_deferred_work (line 295) | static uint64_t
  function pac_retain_grow_limit_get_set (line 316) | bool
  function pac_stash_decayed (line 340) | static size_t
  function pac_decay_stashed (line 362) | static size_t
  function pac_decay_to_limit (line 434) | static void
  function pac_decay_all (line 461) | void
  function pac_decay_try_purge (line 469) | static void
  function pac_maybe_decay_purge (line 480) | bool
  function pac_decay_ms_set (line 519) | bool
  function pac_decay_ms_get (line 549) | ssize_t
  function pac_reset (line 558) | void
  function pac_destroy (line 568) | void

FILE: deps/jemalloc/src/pages.c
  function madvise_MADV_DONTNEED_zeroes_pages (line 62) | static int madvise_MADV_DONTNEED_zeroes_pages()
  function pages_unmap (line 310) | void
  function os_pages_commit (line 318) | static bool
  function pages_commit_impl (line 347) | static bool
  function pages_commit (line 356) | bool
  function pages_decommit (line 361) | bool
  function pages_mark_guards (line 366) | void
  function pages_unmark_guards (line 389) | void
  function pages_purge_lazy (line 426) | bool
  function pages_purge_forced (line 464) | bool
  function pages_huge_impl (line 489) | static bool
  function pages_huge (line 507) | bool
  function pages_huge_unaligned (line 512) | static bool
  function pages_nohuge_impl (line 517) | static bool
  function pages_nohuge (line 531) | bool
  function pages_nohuge_unaligned (line 536) | static bool
  function pages_dontdump (line 541) | bool
  function pages_dodump (line 554) | bool
  function os_page_detect (line 568) | static size_t
  function os_overcommits_sysctl (line 590) | static bool
  function os_overcommits_proc (line 620) | static bool
  function pages_set_thp_state (line 681) | void
  function init_thp_state (line 700) | static void
  function pages_boot (line 757) | bool

FILE: deps/jemalloc/src/pai.c
  function pai_alloc_batch_default (line 4) | size_t
  function pai_dalloc_batch_default (line 21) | void

FILE: deps/jemalloc/src/peak_event.c
  function peak_event_update (line 18) | void
  function peak_event_activity_callback (line 26) | static void
  function peak_event_zero (line 38) | void
  function peak_event_max (line 46) | uint64_t
  function peak_alloc_new_event_wait (line 52) | uint64_t
  function peak_alloc_postponed_event_wait (line 57) | uint64_t
  function peak_alloc_event_handler (line 62) | void
  function peak_dalloc_new_event_wait (line 68) | uint64_t
  function peak_dalloc_postponed_event_wait (line 73) | uint64_t
  function peak_dalloc_event_handler (line 78) | void

FILE: deps/jemalloc/src/prof.c
  function prof_alloc_rollback (line 82) | void
  function prof_malloc_sample_object (line 98) | void
  function prof_free_sampled_object (line 149) | void
  function prof_tctx_t (line 182) | prof_tctx_t *
  function prof_sample_new_event_wait (line 212) | uint64_t
  function prof_sample_postponed_event_wait (line 255) | uint64_t
  function prof_sample_event_handler (line 268) | void
  function prof_fdump (line 280) | static void
  function prof_idump_accum_init (line 296) | static bool
  function prof_idump (line 303) | void
  function prof_mdump (line 330) | bool
  function prof_gdump (line 342) | void
  function prof_thr_uid_alloc (line 369) | static uint64_t
  function prof_tdata_t (line 381) | prof_tdata_t *
  function prof_tdata_t (line 387) | prof_tdata_t *
  function prof_tdata_cleanup (line 400) | void
  function prof_active_get (line 414) | bool
  function prof_active_set (line 425) | bool
  function prof_thread_name_set (line 451) | int
  function prof_thread_active_get (line 460) | bool
  function prof_thread_active_set (line 473) | bool
  function prof_thread_active_init_get (line 487) | bool
  function prof_thread_active_init_set (line 497) | bool
  function prof_gdump_get (line 508) | bool
  function prof_gdump_set (line 518) | bool
  function prof_backtrace_hook_set (line 529) | void
  function prof_backtrace_hook_t (line 534) | prof_backtrace_hook_t
  function prof_dump_hook_set (line 540) | void
  function prof_dump_hook_t (line 545) | prof_dump_hook_t
  function prof_boot0 (line 551) | void
  function prof_boot1 (line 559) | void
  function prof_boot2 (line 586) | bool
  function prof_prefork0 (line 701) | void
  function prof_prefork1 (line 720) | void
  function prof_postfork_parent (line 734) | void
  function prof_postfork_child (line 762) | void

FILE: deps/jemalloc/src/prof_data.c
  function prof_tctx_comp (line 68) | static int
  function malloc_mutex_t (line 134) | static malloc_mutex_t *
  function prof_data_init (line 139) | bool
  function prof_enter (line 146) | static void
  function prof_leave (line 159) | static void
  function prof_gctx_t (line 185) | static prof_gctx_t *
  function prof_gctx_try_destroy (line 211) | static void
  function prof_gctx_should_destroy (line 246) | static bool
  function prof_lookup_global (line 260) | static bool
  function prof_tctx_t (line 325) | prof_tctx_t *
  function prof_tdata_t (line 399) | static prof_tdata_t *
  function prof_tdata_count (line 410) | size_t
  function prof_bt_count (line 425) | size_t
  function prof_thread_name_set_impl (line 467) | int
  function prof_dump_printf (line 508) | static void
  function prof_double_uint64_cast (line 526) | static uint64_t
  function prof_unbias_map_init (line 541) | void prof_unbias_map_init() {
  function prof_do_unbias (line 615) | static void
  function prof_dump_print_cnts (line 646) | static void
  function prof_tctx_merge_tdata (line 669) | static void
  function prof_tctx_merge_gctx (line 708) | static void
  function prof_tctx_t (line 727) | static prof_tctx_t *
  type prof_dump_iter_arg_t (line 748) | typedef struct prof_dump_iter_arg_s prof_dump_iter_arg_t;
  type prof_dump_iter_arg_s (line 749) | struct prof_dump_iter_arg_s {
  function prof_tctx_t (line 755) | static prof_tctx_t *
  function prof_tctx_t (line 779) | static prof_tctx_t *
  function prof_dump_gctx_prep (line 805) | static void
  type prof_gctx_merge_iter_arg_t (line 824) | typedef struct prof_gctx_merge_iter_arg_s prof_gctx_merge_iter_arg_t;
  type prof_gctx_merge_iter_arg_s (line 825) | struct prof_gctx_merge_iter_arg_s {
  function prof_gctx_t (line 830) | static prof_gctx_t *
  function prof_gctx_finish (line 845) | static void
  type prof_tdata_merge_iter_arg_t (line 891) | typedef struct prof_tdata_merge_iter_arg_s prof_tdata_merge_iter_arg_t;
  type prof_tdata_merge_iter_arg_s (line 892) | struct prof_tdata_merge_iter_arg_s {
  function prof_tdata_t (line 897) | static prof_tdata_t *
  function prof_tdata_t (line 941) | static prof_tdata_t *
  function prof_dump_header (line 961) | static void
  function prof_dump_gctx (line 973) | static void
  function prof_leakcheck (line 1015) | static void
  function prof_gctx_t (line 1054) | static prof_gctx_t *
  function prof_dump_prep (line 1063) | static void
  function prof_dump_impl (line 1105) | void
  function prof_cnt_all (line 1124) | void
  function prof_bt_hash (line 1138) | void
  function prof_bt_keycomp (line 1147) | bool
  function prof_tdata_t (line 1160) | prof_tdata_t *
  function prof_tdata_should_destroy_unlocked (line 1205) | static bool
  function prof_tdata_should_destroy (line 1216) | static bool
  function prof_tdata_destroy_locked (line 1224) | static void
  function prof_tdata_destroy (line 1242) | static void
  function prof_tdata_detach (line 1249) | void
  function prof_tdata_expire (line 1274) | static bool
  function prof_tdata_t (line 1290) | static prof_tdata_t *
  function prof_reset (line 1298) | void
  function prof_tctx_should_destroy (line 1326) | static bool
  function prof_tctx_destroy (line 1345) | static void
  function prof_tctx_try_destroy (line 1436) | void

FILE: deps/jemalloc/src/prof_log.c
  type prof_logging_state_t (line 16) | typedef enum prof_logging_state_e prof_logging_state_t;
  type prof_logging_state_e (line 17) | enum prof_logging_state_e {
  type prof_bt_node_t (line 50) | typedef struct prof_bt_node_s prof_bt_node_t;
  type prof_bt_node_s (line 52) | struct prof_bt_node_s {
  type prof_thr_node_t (line 60) | typedef struct prof_thr_node_s prof_thr_node_t;
  type prof_thr_node_s (line 62) | struct prof_thr_node_s {
  type prof_alloc_node_t (line 70) | typedef struct prof_alloc_node_s prof_alloc_node_t;
  type prof_alloc_node_s (line 73) | struct prof_alloc_node_s {
  function prof_log_bt_index (line 123) | static size_t
  function prof_log_thr_index (line 166) | static size_t
  function JEMALLOC_COLD (line 203) | JEMALLOC_COLD
  function prof_bt_node_hash (line 282) | static void
  function prof_bt_node_keycomp (line 288) | static bool
  function prof_thr_node_hash (line 296) | static void
  function prof_thr_node_keycomp (line 302) | static bool
  function prof_log_bt_count (line 310) | size_t
  function prof_log_alloc_count (line 323) | size_t
  function prof_log_thr_count (line 336) | size_t
  function prof_log_is_logging (line 349) | bool
  function prof_log_rep_check (line 356) | bool
  function prof_log_dummy_set (line 409) | void
  function prof_log_stop_final (line 416) | static void
  function JEMALLOC_COLD (line 422) | JEMALLOC_COLD
  type prof_emitter_cb_arg_s (line 472) | struct prof_emitter_cb_arg_s {
  function prof_emitter_write_cb (line 477) | static void
  function prof_log_emit_threads (line 492) | static void
  function prof_log_emit_traces (line 516) | static void
  function prof_log_emit_allocs (line 545) | static void
  function prof_log_emit_metadata (line 584) | static void
  function JEMALLOC_COLD (line 612) | JEMALLOC_COLD
  function JEMALLOC_COLD (line 701) | JEMALLOC_COLD

FILE: deps/jemalloc/src/prof_recent.c
  function prof_recent_alloc_max_init (line 18) | static void
  function prof_recent_alloc_max_get_no_lock (line 24) | static inline ssize_t
  function prof_recent_alloc_max_get (line 29) | static inline ssize_t
  function prof_recent_alloc_max_update (line 35) | static inline ssize_t
  function prof_recent_t (line 43) | static prof_recent_t *
  function prof_recent_free_node (line 50) | static void
  function increment_recent_count (line 57) | static inline void
  function prof_recent_alloc_prepare (line 64) | bool
  function decrement_recent_count (line 93) | static void
  function edata_t (line 103) | static inline edata_t *
  function edata_t (line 108) | edata_t *
  function edata_t (line 114) | static inline edata_t *
  function prof_recent_alloc_edata_set (line 120) | static void
  function edata_prof_recent_alloc_init (line 126) | void
  function prof_recent_t (line 132) | static inline prof_recent_t *
  function prof_recent_t (line 138) | prof_recent_t *
  function prof_recent_t (line 144) | static inline prof_recent_t *
  function prof_recent_t (line 154) | static prof_recent_t *
  function edata_prof_recent_alloc_set (line 164) | static void
  function edata_prof_recent_alloc_reset (line 175) | static void
  function prof_recent_alloc_reset (line 195) | void
  function prof_recent_alloc_evict_edata (line 241) | static void
  function prof_recent_alloc_is_empty (line 250) | static bool
  function prof_recent_alloc_assert_count (line 262) | static void
  function prof_recent_alloc (line 278) | void
  function prof_recent_alloc_max_ctl_read (line 405) | ssize_t
  function prof_recent_alloc_restore_locked (line 412) | static void
  function prof_recent_alloc_async_cleanup (line 444) | static void
  function prof_recent_alloc_max_ctl_write (line 459) | ssize_t
  function prof_recent_alloc_dump_bt (line 473) | static void
  function prof_recent_alloc_dump_node (line 485) | static void
  function JEMALLOC_COLD (line 531) | JEMALLOC_COLD
  function prof_recent_init (line 582) | bool

FILE: deps/jemalloc/src/prof_stats.c
  function prof_stats_enter (line 11) | static void
  function prof_stats_leave (line 18) | static void
  function prof_stats_inc (line 23) | void
  function prof_stats_dec (line 34) | void
  function prof_stats_get_live (line 43) | void
  function prof_stats_get_accum (line 51) | void

FILE: deps/jemalloc/src/prof_sys.c
  function bt_init (line 42) | void
  function prof_backtrace_impl (line 51) | static void
  function _Unwind_Reason_Code (line 67) | static _Unwind_Reason_Code
  function _Unwind_Reason_Code (line 74) | static _Unwind_Reason_Code
  function prof_backtrace_impl (line 94) | static void
  function prof_backtrace_impl (line 105) | static void
  function prof_backtrace_impl (line 270) | static void
  function prof_backtrace (line 277) | void
  function prof_hooks_init (line 288) | void
  function prof_unwind_init (line 294) | void
  function prof_sys_thread_name_read_impl (line 305) | static int
  function prof_sys_thread_name_fetch (line 319) | void
  function prof_getpid (line 329) | int
  type prof_dump_arg_t (line 344) | typedef struct prof_dump_arg_s prof_dump_arg_t;
  type prof_dump_arg_s (line 345) | struct prof_dump_arg_s {
  function prof_dump_check_possible_error (line 364) | static void
  function prof_dump_open_file_impl (line 389) | static int
  function prof_dump_open (line 396) | static void
  function prof_dump_flush (line 405) | static void
  function prof_dump_close (line 417) | static void
  function prof_open_maps_internal (line 426) | static int
  function prof_dump_open_maps_impl (line 449) | static int
  function prof_dump_read_maps_cb (line 471) | static ssize_t
  function prof_dump_maps (line 478) | static void
  function prof_dump (line 490) | static bool
  function prof_strncpy (line 534) | static inline void
  function prof_prefix_is_empty (line 549) | static bool
  function prof_dump_filename (line 559) | static void
  function prof_get_default_filename (line 580) | void
  function prof_fdump_impl (line 588) | void
  function prof_prefix_set (line 599) | bool
  function prof_idump_impl (line 624) | void
  function prof_mdump_impl (line 638) | bool
  function prof_gdump_impl (line 656) | void

FILE: deps/jemalloc/src/psset.c
  function psset_init (line 8) | void
  function psset_bin_stats_accum (line 24) | static void
  function psset_stats_accum (line 31) | void
  function JEMALLOC_ALWAYS_INLINE (line 50) | JEMALLOC_ALWAYS_INLINE void
  function psset_bin_stats_insert (line 83) | static void
  function psset_bin_stats_remove (line 89) | static void
  function psset_hpdata_heap_remove (line 95) | static void
  function psset_hpdata_heap_insert (line 103) | static void
  function psset_stats_insert (line 111) | static void
  function psset_stats_remove (line 129) | static void
  function psset_alloc_container_insert (line 151) | static void
  function psset_alloc_container_remove (line 179) | static void
  function psset_purge_list_ind (line 199) | static size_t
  function psset_maybe_remove_purge_list (line 234) | static void
  function psset_maybe_insert_purge_list (line 252) | static void
  function psset_update_begin (line 265) | void
  function psset_update_end (line 288) | void
  function hpdata_t (line 316) | hpdata_t *
  function hpdata_t (line 337) | hpdata_t *
  function hpdata_t (line 351) | hpdata_t *
  function psset_insert (line 356) | void
  function psset_remove (line 372) | void

FILE: deps/jemalloc/src/rtree.c
  function rtree_new (line 11) | bool
  function rtree_node_elm_t (line 30) | static rtree_node_elm_t *
  function rtree_leaf_elm_t (line 36) | static rtree_leaf_elm_t *
  function rtree_node_elm_t (line 42) | static rtree_node_elm_t *
  function rtree_leaf_elm_t (line 69) | static rtree_leaf_elm_t *
  function rtree_node_valid (line 95) | static bool
  function rtree_leaf_valid (line 100) | static bool
  function rtree_node_elm_t (line 105) | static rtree_node_elm_t *
  function rtree_node_elm_t (line 121) | static rtree_node_elm_t *
  function rtree_leaf_elm_t (line 134) | static rtree_leaf_elm_t *
  function rtree_leaf_elm_t (line 150) | static rtree_leaf_elm_t *
  function rtree_leaf_elm_t (line 163) | rtree_leaf_elm_t *
  function rtree_ctx_data_init (line 249) | void

FILE: deps/jemalloc/src/safety_check.c
  function safety_check_fail_sized_dealloc (line 6) | void safety_check_fail_sized_dealloc(bool current_dealloc, const void *ptr,
  function safety_check_set_abort (line 18) | void safety_check_set_abort(safety_check_abort_hook_t abort_fn) {
  function safety_check_fail (line 22) | void safety_check_fail(const char *format, ...) {

FILE: deps/jemalloc/src/san.c
  function san_find_guarded_addr (line 22) | static inline void
  function san_find_unguarded_addr (line 42) | static inline void
  function san_guard_pages (line 63) | void
  function san_unguard_pages_impl (line 94) | static void
  function san_unguard_pages (line 132) | void
  function san_unguard_pages_pre_destroy (line 139) | void
  function san_stashed_corrupted (line 153) | static bool
  function san_check_stashed_ptrs (line 175) | void
  function tsd_san_init (line 193) | void
  function san_init (line 199) | void

FILE: deps/jemalloc/src/san_bump.c
  function edata_t (line 14) | edata_t *
  function san_bump_grow_locked (line 88) | static bool

FILE: deps/jemalloc/src/sc.c
  function reg_size_compute (line 16) | size_t
  function slab_size (line 22) | static int
  function size_class (line 53) | static void
  function size_classes (line 84) | static void
  function sc_data_init (line 255) | void
  function sc_data_update_sc_slab_size (line 263) | static void
  function sc_data_update_slab_size (line 287) | void
  function sc_boot (line 303) | void

FILE: deps/jemalloc/src/sec.c
  function sec_bin_init (line 16) | static void
  function sec_init (line 23) | bool
  function sec_shard_t (line 88) | static sec_shard_t *
  function sec_flush_some_and_unlock (line 120) | static void
  function edata_t (line 157) | static edata_t *
  function edata_t (line 175) | static edata_t *
  function edata_t (line 220) | static edata_t *
  function sec_expand (line 264) | static bool
  function sec_shrink (line 272) | static bool
  function sec_flush_all_locked (line 280) | static void
  function sec_shard_dalloc_and_unlock (line 303) | static void
  function sec_dalloc (line 336) | static void
  function sec_flush (line 357) | void
  function sec_disable (line 366) | void
  function sec_stats_merge (line 376) | void
  function sec_mutex_stats_read (line 392) | void
  function sec_prefork2 (line 403) | void
  function sec_postfork_parent (line 410) | void
  function sec_postfork_child (line 417) | void

FILE: deps/jemalloc/src/stats.c
  function rate_per_second (line 69) | static uint64_t
  function get_rate_str (line 84) | static bool
  function mutex_stats_init_cols (line 108) | static void
  function mutex_stats_read_global (line 143) | static void
  function mutex_stats_read_arena (line 176) | static void
  function mutex_stats_read_arena_bin (line 209) | static void
  function mutex_stats_emit (line 241) | static void
  function JEMALLOC_COLD (line 301) | JEMALLOC_COLD
  function JEMALLOC_COLD (line 559) | JEMALLOC_COLD
  function JEMALLOC_COLD (line 693) | JEMALLOC_COLD
  function stats_arena_hpa_shard_print (line 787) | static void
  function stats_arena_mutexes_print (line 1011) | static void
  function JEMALLOC_COLD (line 1041) | JEMALLOC_COLD
  function JEMALLOC_COLD (line 1370) | JEMALLOC_COLD
  function JEMALLOC_COLD (line 1679) | JEMALLOC_COLD
  function stats_print (line 1854) | void
  function stats_interval_new_event_wait (line 1917) | uint64_t
  function stats_interval_postponed_event_wait (line 1922) | uint64_t
  function stats_interval_event_handler (line 1927) | void
  function stats_boot (line 1936) | bool
  function stats_prefork (line 1960) | void
  function stats_postfork_parent (line 1965) | void
  function stats_postfork_child (line 1970) | void

FILE: deps/jemalloc/src/sz.c
  function sz_psz_quantize_floor (line 9) | size_t
  function sz_psz_quantize_ceil (line 32) | size_t
  function sz_boot_pind2sz_tab (line 56) | static void
  function sz_boot_index2size_tab (line 75) | static void
  function sz_boot_size2index_tab (line 91) | static void
  function sz_boot (line 108) | void

FILE: deps/jemalloc/src/tcache.c
  function tcache_salloc (line 84) | size_t
  function tcache_gc_new_event_wait (line 89) | uint64_t
  function tcache_gc_postponed_event_wait (line 94) | uint64_t
  function tcache_gc_dalloc_new_event_wait (line 99) | uint64_t
  function tcache_gc_dalloc_postponed_event_wait (line 104) | uint64_t
  function tcache_gc_item_delay_compute (line 109) | static uint8_t
  function tcache_gc_small (line 122) | static void
  function tcache_gc_large (line 161) | static void
  function tcache_event (line 175) | static void
  function tcache_gc_event_handler (line 216) | void
  function tcache_gc_dalloc_event_handler (line 222) | void
  function tcache_bin_flush_metadata_visitor (line 252) | static void
  function JEMALLOC_NOINLINE (line 260) | JEMALLOC_NOINLINE static void
  function tcache_bin_flush_edatas_lookup (line 278) | static void
  function JEMALLOC_ALWAYS_INLINE (line 297) | JEMALLOC_ALWAYS_INLINE bool
  function JEMALLOC_ALWAYS_INLINE (line 308) | JEMALLOC_ALWAYS_INLINE void
  function JEMALLOC_ALWAYS_INLINE (line 505) | JEMALLOC_ALWAYS_INLINE void
  function tcache_bin_flush_small (line 526) | void
  function tcache_bin_flush_large (line 532) | void
  function tcache_bin_flush_stashed (line 548) | void
  function tcache_arena_associate (line 580) | void
  function tcache_arena_dissociate (line 601) | static void
  function tcache_arena_reassociate (line 629) | void
  function tsd_tcache_enabled_data_init (line 636) | bool
  function tcache_init (line 650) | static void
  function tsd_tcache_data_init (line 708) | bool
  function tcache_t (line 753) | tcache_t *
  function tcache_flush_cache (line 782) | static void
  function tcache_flush (line 800) | void
  function tcache_destroy (line 806) | static void
  function tcache_cleanup (line 841) | void
  function tcache_stats_merge (line 862) | void
  function tcaches_create_prep (line 882) | static bool
  function tcaches_create (line 907) | bool
  function tcache_t (line 946) | static tcache_t *
  function tcaches_flush (line 966) | void
  function tcaches_destroy (line 977) | void
  function tcache_ncached_max_compute (line 990) | static unsigned
  function tcache_boot (line 1048) | bool
  function tcache_prefork (line 1084) | void
  function tcache_postfork_parent (line 1089) | void
  function tcache_postfork_child (line 1094) | void
  function tcache_assert_initialized (line 1099) | void tcache_assert_initialized(tcache_t *tcache) {

FILE: deps/jemalloc/src/thread_event.c
  function tcache_gc_fetch_elapsed (line 36) | static uint64_t
  function tcache_gc_dalloc_fetch_elapsed (line 41) | static uint64_t
  function prof_sample_fetch_elapsed (line 46) | static uint64_t
  function stats_interval_fetch_elapsed (line 54) | static uint64_t
  function peak_alloc_fetch_elapsed (line 62) | static uint64_t
  function peak_dalloc_fetch_elapsed (line 67) | static uint64_t
  function te_ctx_has_active_events (line 74) | static bool
  function te_next_event_compute (line 86) | static uint64_t
  function te_assert_invariants_impl (line 105) | static void
  function te_assert_invariants_debug (line 136) | void
  function te_ctx_next_event_fast_update (line 193) | static void
  function te_recompute_fast_threshold (line 201) | void
  function te_adjust_thresholds_helper (line 221) | static void
  function te_clip_event_wait (line 236) | static uint64_t
  function te_event_trigger (line 250) | void
  function te_init (line 305) | static void
  function tsd_te_init (line 336) | void

FILE: deps/jemalloc/src/tsd.c
  type tsd_init_head_s (line 35) | struct tsd_init_head_s {
  function tsd_in_nominal_list (line 65) | static bool
  function tsd_add_nominal (line 84) | static void
  function tsd_remove_nominal (line 94) | static void
  function tsd_force_recompute (line 103) | static void
  function tsd_global_slow_inc (line 124) | void
  function tsd_global_slow_dec (line 138) | void tsd_global_slow_dec(tsdn_t *tsdn) {
  function tsd_local_slow (line 144) | static bool
  function tsd_global_slow (line 150) | bool
  function tsd_state_compute (line 157) | static uint8_t
  function tsd_slow_update (line 170) | void
  function tsd_state_set (line 182) | void
  function tsd_prng_state_init (line 221) | static void
  function tsd_data_init (line 234) | static bool
  function assert_tsd_data_cleanup_done (line 247) | static void
  function tsd_data_init_nocleanup (line 257) | static bool
  function tsd_t (line 277) | tsd_t *
  function malloc_tsd_dalloc (line 331) | void
  function _malloc_thread_cleanup (line 343) | void
  function _malloc_tsd_cleanup_register (line 368) | void
  function tsd_do_data_cleanup (line 377) | static void
  function tsd_cleanup (line 387) | void
  function tsd_t (line 432) | tsd_t *
  function malloc_tsd_boot1 (line 450) | void
  function BOOL (line 459) | static BOOL WINAPI
  function tsd_init_finish (line 523) | void
  function tsd_prefork (line 531) | void
  function tsd_postfork_parent (line 536) | void
  function tsd_postfork_child (line 541) | void

FILE: deps/jemalloc/src/witness.c
  function witness_init (line 7) | void
  function witness_print_witness (line 16) | static void
  function witness_pri

[
  {
    "path": ".codespell/.codespellrc",
    "chars": 139,
    "preview": "[codespell]\nquiet-level = 2\ncount =\nskip = ./deps,./src/crc16_slottable.h,tmp*,./.git,./lcov-html\nignore-words = ./.code"
  },
  {
    "path": ".codespell/requirements.txt",
    "chars": 17,
    "preview": "codespell==2.2.5\n"
  },
  {
    "path": ".codespell/wordlist.txt",
    "chars": 111,
    "preview": "ake\nbale\nfle\nfo\ngameboy\nmutli\nnd\nnees\noll\noptin\not\nsmove\nte\ntre\ncancelability\nist\nstatics\nfiletest\nro\nexat\nclen"
  },
  {
    "path": ".gitattributes",
    "chars": 405,
    "preview": "# We set commands.c's merge driver to `binary` so when it conflicts during a\n# merge git will leave the local version un"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 409,
    "preview": "---\nname: Bug report\nabout: Help us improve Redis by reporting a bug\ntitle: '[BUG]'\nlabels: ''\nassignees: ''\n\n---\n\n**Des"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/crash_report.md",
    "chars": 580,
    "preview": "---\nname: Crash report\nabout: Submit a crash report\ntitle: '[CRASH] <short description>'\nlabels: ''\nassignees: ''\n\n---\n\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 623,
    "preview": "---\nname: Feature request\nabout: Suggest a feature for Redis\ntitle: '[NEW]'\nlabels: ''\nassignees: ''\n\n---\n\n**The problem"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/other_stuff.md",
    "chars": 110,
    "preview": "---\nname: Other\nabout: Can't find the right issue type? Use this one!\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/question.md",
    "chars": 941,
    "preview": "---\nname: Question\nabout: Ask the Redis developers\ntitle: '[QUESTION]'\nlabels: ''\nassignees: ''\n\n---\n\nPlease keep in min"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 526,
    "preview": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where "
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 3174,
    "preview": "name: CI\n\non: [push, pull_request]\n\njobs:\n\n  test-ubuntu-latest:\n    runs-on: ubuntu-latest\n    steps:\n    - uses: actio"
  },
  {
    "path": ".github/workflows/codecov.yml",
    "chars": 801,
    "preview": "name: \"Codecov\"\n\n# Enabling on each push is to display the coverage changes in every PR, \n# where each PR needs to be co"
  },
  {
    "path": ".github/workflows/codeql-analysis.yml",
    "chars": 706,
    "preview": "name: \"CodeQL\"\n\non:\n  pull_request:\n  schedule:\n    # run weekly new vulnerability was added to the database\n    - cron:"
  },
  {
    "path": ".github/workflows/coverity.yml",
    "chars": 1504,
    "preview": "# Creates and uploads a Coverity build on a schedule\nname: Coverity Scan\non:\n  schedule:\n  # Run once daily, since below"
  },
  {
    "path": ".github/workflows/daily.yml",
    "chars": 65972,
    "preview": "name: Daily\n\non:\n  pull_request:\n    branches:\n      # any PR to a release branch.\n      - '[0-9].[0-9]'\n  schedule:\n   "
  },
  {
    "path": ".github/workflows/external.yml",
    "chars": 2731,
    "preview": "name: External Server Tests\n\non:\n    pull_request:\n    push:\n    schedule:\n      - cron: '0 0 * * *'\n\njobs:\n  test-exter"
  },
  {
    "path": ".github/workflows/post-release-automation.yml",
    "chars": 6117,
    "preview": "name: Post-Release Automation\n\non:\n  release:\n    types: [published]\n\njobs:\n  extract-release-info:\n    if: github.repos"
  },
  {
    "path": ".github/workflows/redis_docs_sync.yaml",
    "chars": 1099,
    "preview": "name: redis_docs_sync\n\non:\n  release:\n    types: [published]\n\njobs:\n  redis_docs_sync:\n    if: github.repository == 'red"
  },
  {
    "path": ".github/workflows/reply-schemas-linter.yml",
    "chars": 435,
    "preview": "name: Reply-schemas linter\n\non:\n  push:\n    paths:\n      - 'src/commands/*.json'\n  pull_request:\n    paths:\n      - 'src"
  },
  {
    "path": ".github/workflows/spell-check.yml",
    "chars": 857,
    "preview": "# A CI action that using codespell to check spell.\n# .github/.codespellrc is a config file.\n# .github/wordlist.txt is a "
  },
  {
    "path": ".gitignore",
    "chars": 559,
    "preview": ".*.swp\n*.o\n*.xo\n*.so\n*.d\n*.log\ndump.rdb\nredis-benchmark\nredis-check-aof\nredis-check-rdb\nredis-check-dump\nredis-cli\nredis"
  },
  {
    "path": "00-RELEASENOTES",
    "chars": 627,
    "preview": "Hello! This file is just a placeholder, since this is the \"unstable\" branch\nof Redis, the place where all the developmen"
  },
  {
    "path": "BUGS",
    "chars": 51,
    "preview": "Please check https://github.com/redis/redis/issues\n"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5023,
    "preview": "Contributor Covenant Code of Conduct\nOur Pledge\nWe as members, contributors, and leaders pledge to make participation in"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 7218,
    "preview": "By contributing code to the Redis project in any form you agree to the Redis Software Grant and\nContributor License Agre"
  },
  {
    "path": "INSTALL",
    "chars": 11,
    "preview": "See README\n"
  },
  {
    "path": "LICENSE.txt",
    "chars": 72266,
    "preview": "Starting with Redis 8, Redis Open Source is moving to a tri-licensing model with all new Redis code\ncontributions govern"
  },
  {
    "path": "MANIFESTO",
    "chars": 6888,
    "preview": "[Note: this is the Redis manifesto, for general information about\n       installing and running Redis read the README fi"
  },
  {
    "path": "Makefile",
    "chars": 426,
    "preview": "# Top level makefile, the real stuff is at ./src/Makefile and in ./modules/Makefile\n\nSUBDIRS = src\nifeq ($(BUILD_WITH_MO"
  },
  {
    "path": "README.md",
    "chars": 39163,
    "preview": "[![codecov](https://codecov.io/github/redis/redis/graph/badge.svg?token=6bVHb5fRuz)](https://codecov.io/github/redis/red"
  },
  {
    "path": "REDISCONTRIBUTIONS.txt",
    "chars": 1853,
    "preview": "Copyright (c) 2006-Present, Redis Ltd. and Contributors\nAll rights reserved.\n\nNote: Continued Applicability of the BSD-3"
  },
  {
    "path": "SECURITY.md",
    "chars": 3690,
    "preview": "# Security Policy\n\n## Supported Versions\n\nRedis is generally backward compatible with very few exceptions, so we\nrecomme"
  },
  {
    "path": "TLS.md",
    "chars": 3628,
    "preview": "TLS Support\n===========\n\nGetting Started\n---------------\n\n### Building\n\nTo build with TLS support you'll need OpenSSL de"
  },
  {
    "path": "codecov.yml",
    "chars": 339,
    "preview": "coverage:\n  status:\n    patch:\n      default:\n        informational: true\n    project:\n      default:\n        informatio"
  },
  {
    "path": "deps/Makefile",
    "chars": 4766,
    "preview": "# Redis dependency Makefile\n\nuname_S:= $(shell sh -c 'uname -s 2>/dev/null || echo not')\n\nLUA_DEBUG?=no\nLUA_COVERAGE?=no"
  },
  {
    "path": "deps/README.md",
    "chars": 5582,
    "preview": "This directory contains all Redis dependencies, except for the libc that\nshould be provided by the operating system.\n\n* "
  },
  {
    "path": "deps/fpconv/LICENSE.txt",
    "chars": 1338,
    "preview": "Boost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or"
  },
  {
    "path": "deps/fpconv/Makefile",
    "chars": 331,
    "preview": "STD=\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS)\nR_LDFLAGS= $(LDFLAGS)\nDEBUG= -g\n\nR_CC=$(CC"
  },
  {
    "path": "deps/fpconv/README.md",
    "chars": 453,
    "preview": "libfpconv\n\n----------------------------------------------\n\nFast and accurate double to string conversion based on Floria"
  },
  {
    "path": "deps/fpconv/fpconv_dtoa.c",
    "chars": 9632,
    "preview": "/* fpconv_dtoa.c -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on Fl"
  },
  {
    "path": "deps/fpconv/fpconv_dtoa.h",
    "chars": 2066,
    "preview": "/* fpconv_dtoa.h -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on Fl"
  },
  {
    "path": "deps/fpconv/fpconv_powers.h",
    "chars": 6010,
    "preview": "/* fpconv_powers.h -- floating point conversion utilities.\n *\n * Fast and accurate double to string conversion based on "
  },
  {
    "path": "deps/hdr_histogram/COPYING.txt",
    "chars": 7048,
    "preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
  },
  {
    "path": "deps/hdr_histogram/LICENSE.txt",
    "chars": 2161,
    "preview": "The code in this repository code was Written by Gil Tene, Michael Barker,\nand Matt Warren, and released to the public do"
  },
  {
    "path": "deps/hdr_histogram/Makefile",
    "chars": 398,
    "preview": "STD= -std=c99\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) -DHDR_MALLOC_INCLUDE=\\\"hdr_redis_"
  },
  {
    "path": "deps/hdr_histogram/README.md",
    "chars": 2125,
    "preview": "HdrHistogram_c: 'C' port of High Dynamic Range (HDR) Histogram\n\nHdrHistogram\n-------------------------------------------"
  },
  {
    "path": "deps/hdr_histogram/hdr_atomic.h",
    "chars": 3842,
    "preview": "/**\n * hdr_atomic.h\n * Written by Philip Orwig and released to the public domain,\n * as explained at http://creativecomm"
  },
  {
    "path": "deps/hdr_histogram/hdr_histogram.c",
    "chars": 37416,
    "preview": "/**\n * hdr_histogram.c\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativ"
  },
  {
    "path": "deps/hdr_histogram/hdr_histogram.h",
    "chars": 17830,
    "preview": "/**\n * hdr_histogram.h\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativ"
  },
  {
    "path": "deps/hdr_histogram/hdr_redis_malloc.h",
    "chars": 300,
    "preview": "#ifndef HDR_MALLOC_H__\n#define HDR_MALLOC_H__\n\nvoid *zmalloc(size_t size);\nvoid *zcalloc_num(size_t num, size_t size);\nv"
  },
  {
    "path": "deps/hdr_histogram/hdr_tests.h",
    "chars": 631,
    "preview": "#ifndef HDR_TESTS_H\n#define HDR_TESTS_H\n\n/* These are functions used in tests and are not intended for normal usage. */\n"
  },
  {
    "path": "deps/hiredis/.github/release-drafter-config.yml",
    "chars": 932,
    "preview": "name-template: '$NEXT_MAJOR_VERSION'\ntag-template: 'v$NEXT_MAJOR_VERSION'\nautolabeler:\n  - label: 'maintenance'\n    file"
  },
  {
    "path": "deps/hiredis/.github/workflows/build.yml",
    "chars": 5131,
    "preview": "name: Build and test\non: [push, pull_request]\n\njobs:\n  ubuntu:\n    name: Ubuntu\n    runs-on: ubuntu-latest\n    steps:\n  "
  },
  {
    "path": "deps/hiredis/.github/workflows/release-drafter.yml",
    "chars": 562,
    "preview": "name: Release Drafter\n\non:\n  push:\n    # branches to consider in the event; optional, defaults to all\n    branches:\n    "
  },
  {
    "path": "deps/hiredis/.github/workflows/test.yml",
    "chars": 3033,
    "preview": "name: C/C++ CI\n\non:\n  push:\n    branches: [ master ]\n  pull_request:\n    branches: [ master ]\n\njobs:\n  full-build:\n    n"
  },
  {
    "path": "deps/hiredis/.gitignore",
    "chars": 84,
    "preview": "/hiredis-test\n/examples/hiredis-example*\n/*.o\n/*.so\n/*.dylib\n/*.a\n/*.pc\n*.dSYM\ntags\n"
  },
  {
    "path": "deps/hiredis/.travis.yml",
    "chars": 3242,
    "preview": "language: c\ncompiler:\n  - gcc\n  - clang\n\nos:\n  - linux\n  - osx\n\ndist: bionic\n\nbranches:\n  only:\n    - staging\n    - tryi"
  },
  {
    "path": "deps/hiredis/CHANGELOG.md",
    "chars": 44747,
    "preview": "## [1.2.0](https://github.com/redis/hiredis/tree/v1.2.0) - (2023-06-04)\n\nAnnouncing Hiredis v1.2.0 with with new adapter"
  },
  {
    "path": "deps/hiredis/CMakeLists.txt",
    "chars": 8129,
    "preview": "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)\n\nOPTION(BUILD_SHARED_LIBS \"Build shared libraries\" ON)\nOPTION(ENABLE_SSL \"Build hi"
  },
  {
    "path": "deps/hiredis/COPYING",
    "chars": 1588,
    "preview": "Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\nCopyright (c) 2010-2011, Pieter Noordhuis <pcno"
  },
  {
    "path": "deps/hiredis/Makefile",
    "chars": 13596,
    "preview": "# Hiredis Makefile\n# Copyright (C) 2010-2011 Salvatore Sanfilippo <antirez at gmail dot com>\n# Copyright (C) 2010-2011 P"
  },
  {
    "path": "deps/hiredis/README.md",
    "chars": 35844,
    "preview": "\n[![Build Status](https://github.com/redis/hiredis/actions/workflows/build.yml/badge.svg)](https://github.com/redis/hire"
  },
  {
    "path": "deps/hiredis/adapters/ae.h",
    "chars": 4271,
    "preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
  },
  {
    "path": "deps/hiredis/adapters/glib.h",
    "chars": 3854,
    "preview": "#ifndef __HIREDIS_GLIB_H__\n#define __HIREDIS_GLIB_H__\n\n#include <glib.h>\n\n#include \"../hiredis.h\"\n#include \"../async.h\"\n"
  },
  {
    "path": "deps/hiredis/adapters/ivykis.h",
    "chars": 2327,
    "preview": "#ifndef __HIREDIS_IVYKIS_H__\n#define __HIREDIS_IVYKIS_H__\n#include <iv.h>\n#include \"../hiredis.h\"\n#include \"../async.h\"\n"
  },
  {
    "path": "deps/hiredis/adapters/libev.h",
    "chars": 5597,
    "preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
  },
  {
    "path": "deps/hiredis/adapters/libevent.h",
    "chars": 5613,
    "preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
  },
  {
    "path": "deps/hiredis/adapters/libhv.h",
    "chars": 3398,
    "preview": "#ifndef __HIREDIS_LIBHV_H__\n#define __HIREDIS_LIBHV_H__\n\n#include <hv/hloop.h>\n#include \"../hiredis.h\"\n#include \"../asyn"
  },
  {
    "path": "deps/hiredis/adapters/libsdevent.h",
    "chars": 4953,
    "preview": "#ifndef HIREDIS_LIBSDEVENT_H\n#define HIREDIS_LIBSDEVENT_H\n#include <systemd/sd-event.h>\n#include \"../hiredis.h\"\n#include"
  },
  {
    "path": "deps/hiredis/adapters/libuv.h",
    "chars": 4506,
    "preview": "#ifndef __HIREDIS_LIBUV_H__\n#define __HIREDIS_LIBUV_H__\n#include <stdlib.h>\n#include <uv.h>\n#include \"../hiredis.h\"\n#inc"
  },
  {
    "path": "deps/hiredis/adapters/macosx.h",
    "chars": 3870,
    "preview": "//\n//  Created by Дмитрий Бахвалов on 13.07.15.\n//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#ifnde"
  },
  {
    "path": "deps/hiredis/adapters/poll.h",
    "chars": 5260,
    "preview": "\n#ifndef HIREDIS_POLL_H\n#define HIREDIS_POLL_H\n\n#include \"../async.h\"\n#include \"../sockcompat.h\"\n#include <string.h> // "
  },
  {
    "path": "deps/hiredis/adapters/qt.h",
    "chars": 4233,
    "preview": "/*-\n * Copyright (C) 2014 Pietro Cerutti <gahr@gahr.ch>\n *\n * Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "deps/hiredis/adapters/redismoduleapi.h",
    "chars": 4122,
    "preview": "#ifndef __HIREDIS_REDISMODULEAPI_H__\n#define __HIREDIS_REDISMODULEAPI_H__\n\n#include \"redismodule.h\"\n\n#include \"../async."
  },
  {
    "path": "deps/hiredis/alloc.c",
    "chars": 2928,
    "preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
  },
  {
    "path": "deps/hiredis/alloc.h",
    "chars": 3130,
    "preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
  },
  {
    "path": "deps/hiredis/appveyor.yml",
    "chars": 743,
    "preview": "# Appveyor configuration file for CI build of hiredis on Windows (under Cygwin)\nenvironment:\n    matrix:\n        - CYG_B"
  },
  {
    "path": "deps/hiredis/async.c",
    "chars": 33976,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/async.h",
    "chars": 6288,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/async_private.h",
    "chars": 3367,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/dict.c",
    "chars": 10650,
    "preview": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-rand"
  },
  {
    "path": "deps/hiredis/dict.h",
    "chars": 4650,
    "preview": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-rand"
  },
  {
    "path": "deps/hiredis/examples/CMakeLists.txt",
    "chars": 1664,
    "preview": "INCLUDE(FindPkgConfig)\n# Check for GLib\n\nPKG_CHECK_MODULES(GLIB2 glib-2.0)\nif (GLIB2_FOUND)\n    INCLUDE_DIRECTORIES(${GL"
  },
  {
    "path": "deps/hiredis/examples/example-ae.c",
    "chars": 1583,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-glib.c",
    "chars": 1632,
    "preview": "#include <stdlib.h>\n\n#include <hiredis.h>\n#include <async.h>\n#include <adapters/glib.h>\n\nstatic GMainLoop *mainloop;\n\nst"
  },
  {
    "path": "deps/hiredis/examples/example-ivykis.c",
    "chars": 1440,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-libev.c",
    "chars": 1427,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-libevent-ssl.c",
    "chars": 2343,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <hiredis_s"
  },
  {
    "path": "deps/hiredis/examples/example-libevent.c",
    "chars": 1750,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-libhv.c",
    "chars": 1936,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-libsdevent.c",
    "chars": 2834,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-libuv.c",
    "chars": 2572,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-macosx.c",
    "chars": 1639,
    "preview": "//\n//  Created by Дмитрий Бахвалов on 13.07.15.\n//  Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#inclu"
  },
  {
    "path": "deps/hiredis/examples/example-poll.c",
    "chars": 1569,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n#include <unistd.h>\n\n#include <async.h>\n#"
  },
  {
    "path": "deps/hiredis/examples/example-push.c",
    "chars": 6009,
    "preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
  },
  {
    "path": "deps/hiredis/examples/example-qt.cpp",
    "chars": 1047,
    "preview": "#include <iostream>\nusing namespace std;\n\n#include <QCoreApplication>\n#include <QTimer>\n\n#include \"example-qt.h\"\n\nvoid g"
  },
  {
    "path": "deps/hiredis/examples/example-qt.h",
    "chars": 620,
    "preview": "#ifndef __HIREDIS_EXAMPLE_QT_H\n#define __HIREDIS_EXAMPLE_QT_H\n\n#include <adapters/qt.h>\n\nclass ExampleQt : public QObjec"
  },
  {
    "path": "deps/hiredis/examples/example-redismoduleapi.c",
    "chars": 3304,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
  },
  {
    "path": "deps/hiredis/examples/example-ssl.c",
    "chars": 3196,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include <hiredis.h>\n#include <hiredis_ssl.h>\n\n#ifdef _MSC_V"
  },
  {
    "path": "deps/hiredis/examples/example.c",
    "chars": 4141,
    "preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <hiredis.h>\n\n#ifdef _MSC_VER\n#include <winsock2.h> /"
  },
  {
    "path": "deps/hiredis/fmacros.h",
    "chars": 245,
    "preview": "#ifndef __HIREDIS_FMACRO_H\n#define __HIREDIS_FMACRO_H\n\n#ifndef _AIX\n#define _XOPEN_SOURCE 600\n#define _POSIX_C_SOURCE 20"
  },
  {
    "path": "deps/hiredis/fuzzing/format_command_fuzzer.c",
    "chars": 2242,
    "preview": "/*\n * Copyright (c) 2020, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2020, Pieter Noordhuis <pcnoo"
  },
  {
    "path": "deps/hiredis/hiredis-config.cmake.in",
    "chars": 336,
    "preview": "@PACKAGE_INIT@\n\nset_and_check(hiredis_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\nIF (NOT TARGET hiredis::@hiredis_expo"
  },
  {
    "path": "deps/hiredis/hiredis.c",
    "chars": 37158,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2014, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/hiredis.h",
    "chars": 14325,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2014, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/hiredis.pc.in",
    "chars": 385,
    "preview": "prefix=@CMAKE_INSTALL_PREFIX@\ninstall_libdir=@CMAKE_INSTALL_LIBDIR@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/${instal"
  },
  {
    "path": "deps/hiredis/hiredis.targets",
    "chars": 522,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuil"
  },
  {
    "path": "deps/hiredis/hiredis_ssl-config.cmake.in",
    "chars": 400,
    "preview": "@PACKAGE_INIT@\n\nset_and_check(hiredis_ssl_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\ninclude(CMakeFindDependencyMacro)"
  },
  {
    "path": "deps/hiredis/hiredis_ssl.h",
    "chars": 6080,
    "preview": "\n/*\n * Copyright (c) 2019, Redis Labs\n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms"
  },
  {
    "path": "deps/hiredis/hiredis_ssl.pc.in",
    "chars": 358,
    "preview": "prefix=@CMAKE_INSTALL_PREFIX@\ninstall_libdir=@CMAKE_INSTALL_LIBDIR@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/${instal"
  },
  {
    "path": "deps/hiredis/net.c",
    "chars": 20886,
    "preview": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfili"
  },
  {
    "path": "deps/hiredis/net.h",
    "chars": 2836,
    "preview": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfili"
  },
  {
    "path": "deps/hiredis/read.c",
    "chars": 23497,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/read.h",
    "chars": 4918,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/sds.c",
    "chars": 41884,
    "preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
  },
  {
    "path": "deps/hiredis/sds.h",
    "chars": 9798,
    "preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
  },
  {
    "path": "deps/hiredis/sdsalloc.h",
    "chars": 2130,
    "preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
  },
  {
    "path": "deps/hiredis/sdscompat.h",
    "chars": 3556,
    "preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
  },
  {
    "path": "deps/hiredis/sockcompat.c",
    "chars": 9889,
    "preview": "/*\n * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>\n *\n * All rights reserved.\n *\n * Redistribution and u"
  },
  {
    "path": "deps/hiredis/sockcompat.h",
    "chars": 4409,
    "preview": "/*\n * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>\n *\n * All rights reserved.\n *\n * Redistribution and u"
  },
  {
    "path": "deps/hiredis/ssl.c",
    "chars": 17463,
    "preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
  },
  {
    "path": "deps/hiredis/test.c",
    "chars": 85254,
    "preview": "#include \"fmacros.h\"\n#include \"sockcompat.h\"\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#ifndef _WIN32\n#"
  },
  {
    "path": "deps/hiredis/test.sh",
    "chars": 2985,
    "preview": "#!/bin/sh -ue\n\nREDIS_SERVER=${REDIS_SERVER:-redis-server}\nREDIS_PORT=${REDIS_PORT:-56379}\nREDIS_SSL_PORT=${REDIS_SSL_POR"
  },
  {
    "path": "deps/hiredis/win32.h",
    "chars": 1042,
    "preview": "#ifndef _WIN32_HELPER_INCLUDE\n#define _WIN32_HELPER_INCLUDE\n#ifdef _MSC_VER\n\n#include <winsock2.h> /* for struct timeval"
  },
  {
    "path": "deps/jemalloc/.appveyor.yml",
    "chars": 936,
    "preview": "version: '{build}'\n\nenvironment:\n  matrix:\n  - MSYSTEM: MINGW64\n    CPU: x86_64\n    MSVC: amd64\n    CONFIG_FLAGS: --enab"
  },
  {
    "path": "deps/jemalloc/.autom4te.cfg",
    "chars": 107,
    "preview": "begin-language: \"Autoconf-without-aclocal-m4\"\nargs: --no-cache\nend-language: \"Autoconf-without-aclocal-m4\"\n"
  },
  {
    "path": "deps/jemalloc/.cirrus.yml",
    "chars": 1213,
    "preview": "env:\n  CIRRUS_CLONE_DEPTH: 1\n  ARCH: amd64\n\ntask:\n  matrix:\n      env:\n        DEBUG_CONFIG: --enable-debug\n      env:\n "
  },
  {
    "path": "deps/jemalloc/.clang-format",
    "chars": 3592,
    "preview": "# jemalloc targets clang-format version 8.  We include every option it supports\n# here, but comment out the ones that ar"
  },
  {
    "path": "deps/jemalloc/.gitattributes",
    "chars": 19,
    "preview": "* text=auto eol=lf\n"
  },
  {
    "path": "deps/jemalloc/.gitignore",
    "chars": 2027,
    "preview": "/bin/jemalloc-config\n/bin/jemalloc.sh\n/bin/jeprof\n\n/config.stamp\n/config.log\n/config.status\n/configure\n\n/doc/html.xsl\n/d"
  },
  {
    "path": "deps/jemalloc/.travis.yml",
    "chars": 21404,
    "preview": "# This config file is generated by ./scripts/gen_travis.py.\n# Do not edit by hand.\n\n# We use 'minimal', because 'generic"
  },
  {
    "path": "deps/jemalloc/COPYING",
    "chars": 1709,
    "preview": "Unless otherwise specified, files in the jemalloc source distribution are\nsubject to the following license:\n------------"
  },
  {
    "path": "deps/jemalloc/ChangeLog",
    "chars": 79459,
    "preview": "Following are change highlights associated with official releases.  Important\nbug fixes are all mentioned, but some inte"
  },
  {
    "path": "deps/jemalloc/INSTALL.md",
    "chars": 14797,
    "preview": "Building and installing a packaged release of jemalloc can be as simple as\ntyping the following while in the root direct"
  },
  {
    "path": "deps/jemalloc/Makefile.in",
    "chars": 27342,
    "preview": "# Clear out all vpaths, then set just one (default vpath) for the main build\n# directory.\nvpath\nvpath % .\n\n# Clear the d"
  },
  {
    "path": "deps/jemalloc/README",
    "chars": 1047,
    "preview": "jemalloc is a general purpose malloc(3) implementation that emphasizes\nfragmentation avoidance and scalable concurrency "
  },
  {
    "path": "deps/jemalloc/TUNING.md",
    "chars": 5935,
    "preview": "This document summarizes the common approaches for performance fine tuning with\njemalloc (as of 5.3.0).  The default con"
  },
  {
    "path": "deps/jemalloc/VERSION",
    "chars": 11,
    "preview": "5.3.0-0-g0\n"
  },
  {
    "path": "deps/jemalloc/autogen.sh",
    "chars": 266,
    "preview": "#!/bin/sh\n\nfor i in autoconf; do\n    echo \"$i\"\n    $i\n    if [ $? -ne 0 ]; then\n\techo \"Error $? in $i\"\n\texit 1\n    fi\ndo"
  },
  {
    "path": "deps/jemalloc/bin/jemalloc-config.in",
    "chars": 1598,
    "preview": "#!/bin/sh\n\nusage() {\n\tcat <<EOF\nUsage:\n  @BINDIR@/jemalloc-config <option>\nOptions:\n  --help | -h  : Print usage.\n  --ve"
  },
  {
    "path": "deps/jemalloc/bin/jemalloc.sh.in",
    "chars": 151,
    "preview": "#!/bin/sh\n\nprefix=@prefix@\nexec_prefix=@exec_prefix@\nlibdir=@libdir@\n\n@LD_PRELOAD_VAR@=${libdir}/libjemalloc.@SOREV@\nexp"
  },
  {
    "path": "deps/jemalloc/bin/jeprof.in",
    "chars": 182667,
    "preview": "#! /usr/bin/env perl\n\n# Copyright (c) 1998-2007, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source"
  },
  {
    "path": "deps/jemalloc/build-aux/config.guess",
    "chars": 49448,
    "preview": "#! /bin/sh\n# Attempt to guess a canonical system name.\n#   Copyright 1992-2021 Free Software Foundation, Inc.\n\ntimestamp"
  },
  {
    "path": "deps/jemalloc/build-aux/config.sub",
    "chars": 34267,
    "preview": "#! /bin/sh\n# Configuration validation subroutine script.\n#   Copyright 1992-2021 Free Software Foundation, Inc.\n\ntimesta"
  },
  {
    "path": "deps/jemalloc/build-aux/install-sh",
    "chars": 5585,
    "preview": "#! /bin/sh\n#\n# install - install a program, script, or datafile\n# This comes from X11R5 (mit/util/scripts/install.sh).\n#"
  },
  {
    "path": "deps/jemalloc/config.stamp.in",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "deps/jemalloc/configure",
    "chars": 440426,
    "preview": "#! /bin/sh\n# Guess values for system-dependent variables and create Makefiles.\n# Generated by GNU Autoconf 2.71.\n#\n#\n# C"
  },
  {
    "path": "deps/jemalloc/configure.ac",
    "chars": 83743,
    "preview": "dnl Process this file with autoconf to produce a configure script.\nAC_PREREQ(2.68)\nAC_INIT([Makefile.in])\n\nAC_CONFIG_AUX"
  },
  {
    "path": "deps/jemalloc/doc/html.xsl.in",
    "chars": 249,
    "preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n  <xsl:import href=\"@XSLROOT@/html/docbo"
  },
  {
    "path": "deps/jemalloc/doc/jemalloc.xml.in",
    "chars": 172776,
    "preview": "<?xml version='1.0' encoding='UTF-8'?>\n<?xml-stylesheet type=\"text/xsl\"\n        href=\"http://docbook.sourceforge.net/rel"
  },
  {
    "path": "deps/jemalloc/doc/manpages.xsl.in",
    "chars": 207,
    "preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n  <xsl:import href=\"@XSLROOT@/manpages/d"
  },
  {
    "path": "deps/jemalloc/doc/stylesheet.xsl",
    "chars": 415,
    "preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n  <xsl:param name=\"funcsynopsis.style\">a"
  },
  {
    "path": "deps/jemalloc/doc_internal/PROFILING_INTERNALS.md",
    "chars": 12740,
    "preview": "# jemalloc profiling\nThis describes the mathematical basis behind jemalloc's profiling implementation, as well as the im"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/activity_callback.h",
    "chars": 815,
    "preview": "#ifndef JEMALLOC_INTERNAL_ACTIVITY_CALLBACK_H\n#define JEMALLOC_INTERNAL_ACTIVITY_CALLBACK_H\n\n/*\n * The callback to be ex"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_externs.h",
    "chars": 5491,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n#define JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n\n#include \"jemalloc/internal/bin.h\"\n"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_a.h",
    "chars": 627,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n\nstatic inline unsigned\narena_in"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_b.h",
    "chars": 16344,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n\n#include \"jemalloc/internal/div"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_stats.h",
    "chars": 3570,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_STATS_H\n#define JEMALLOC_INTERNAL_ARENA_STATS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_structs.h",
    "chars": 2987,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_STRUCTS_H\n#define JEMALLOC_INTERNAL_ARENA_STRUCTS_H\n\n#include \"jemalloc/internal/arena_s"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/arena_types.h",
    "chars": 1738,
    "preview": "#ifndef JEMALLOC_INTERNAL_ARENA_TYPES_H\n#define JEMALLOC_INTERNAL_ARENA_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n/* D"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/assert.h",
    "chars": 1330,
    "preview": "#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/util.h\"\n\n/*\n * Define a custom assert() in order to"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/atomic.h",
    "chars": 3584,
    "preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_H\n\n#define ATOMIC_INLINE JEMALLOC_ALWAYS_INLINE\n\n#de"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/atomic_c11.h",
    "chars": 3546,
    "preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_C11_H\n#define JEMALLOC_INTERNAL_ATOMIC_C11_H\n\n#include <stdatomic.h>\n\n#define ATOMIC_IN"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_atomic.h",
    "chars": 4153,
    "preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n\n#include \"jemalloc/internal"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_sync.h",
    "chars": 6363,
    "preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n\n#define ATOMIC_INIT(...) {__VA_"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/atomic_msvc.h",
    "chars": 5540,
    "preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n#define JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n\n#define ATOMIC_INIT(...) {__VA_ARGS__}\n"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/background_thread_externs.h",
    "chars": 1393,
    "preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n\nextern bool"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/background_thread_inlines.h",
    "chars": 1716,
    "preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n\nJEMALLOC_AL"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/background_thread_structs.h",
    "chars": 2239,
    "preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n\n/* This fil"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/base.h",
    "chars": 3305,
    "preview": "#ifndef JEMALLOC_INTERNAL_BASE_H\n#define JEMALLOC_INTERNAL_BASE_H\n\n#include \"jemalloc/internal/edata.h\"\n#include \"jemall"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bin.h",
    "chars": 2535,
    "preview": "#ifndef JEMALLOC_INTERNAL_BIN_H\n#define JEMALLOC_INTERNAL_BIN_H\n\n#include \"jemalloc/internal/bin_stats.h\"\n#include \"jema"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bin_info.h",
    "chars": 1370,
    "preview": "#ifndef JEMALLOC_INTERNAL_BIN_INFO_H\n#define JEMALLOC_INTERNAL_BIN_INFO_H\n\n#include \"jemalloc/internal/bitmap.h\"\n\n/*\n * "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bin_stats.h",
    "chars": 1486,
    "preview": "#ifndef JEMALLOC_INTERNAL_BIN_STATS_H\n#define JEMALLOC_INTERNAL_BIN_STATS_H\n\n#include \"jemalloc/internal/mutex_prof.h\"\n\n"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bin_types.h",
    "chars": 473,
    "preview": "#ifndef JEMALLOC_INTERNAL_BIN_TYPES_H\n#define JEMALLOC_INTERNAL_BIN_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n#define "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bit_util.h",
    "chars": 10314,
    "preview": "#ifndef JEMALLOC_INTERNAL_BIT_UTIL_H\n#define JEMALLOC_INTERNAL_BIT_UTIL_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/* San"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/bitmap.h",
    "chars": 11154,
    "preview": "#ifndef JEMALLOC_INTERNAL_BITMAP_H\n#define JEMALLOC_INTERNAL_BITMAP_H\n\n#include \"jemalloc/internal/bit_util.h\"\n#include "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/buf_writer.h",
    "chars": 1169,
    "preview": "#ifndef JEMALLOC_INTERNAL_BUF_WRITER_H\n#define JEMALLOC_INTERNAL_BUF_WRITER_H\n\n/*\n * Note: when using the buffered write"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/cache_bin.h",
    "chars": 22427,
    "preview": "#ifndef JEMALLOC_INTERNAL_CACHE_BIN_H\n#define JEMALLOC_INTERNAL_CACHE_BIN_H\n\n#include \"jemalloc/internal/ql.h\"\n#include "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/ckh.h",
    "chars": 3265,
    "preview": "#ifndef JEMALLOC_INTERNAL_CKH_H\n#define JEMALLOC_INTERNAL_CKH_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/* Cuckoo hashing i"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/counter.h",
    "chars": 1164,
    "preview": "#ifndef JEMALLOC_INTERNAL_COUNTER_H\n#define JEMALLOC_INTERNAL_COUNTER_H\n\n#include \"jemalloc/internal/mutex.h\"\n\ntypedef s"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/ctl.h",
    "chars": 4649,
    "preview": "#ifndef JEMALLOC_INTERNAL_CTL_H\n#define JEMALLOC_INTERNAL_CTL_H\n\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/decay.h",
    "chars": 6255,
    "preview": "#ifndef JEMALLOC_INTERNAL_DECAY_H\n#define JEMALLOC_INTERNAL_DECAY_H\n\n#include \"jemalloc/internal/smoothstep.h\"\n\n#define "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/div.h",
    "chars": 1172,
    "preview": "#ifndef JEMALLOC_INTERNAL_DIV_H\n#define JEMALLOC_INTERNAL_DIV_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * This modul"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/ecache.h",
    "chars": 1610,
    "preview": "#ifndef JEMALLOC_INTERNAL_ECACHE_H\n#define JEMALLOC_INTERNAL_ECACHE_H\n\n#include \"jemalloc/internal/eset.h\"\n#include \"jem"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/edata.h",
    "chars": 20927,
    "preview": "#ifndef JEMALLOC_INTERNAL_EDATA_H\n#define JEMALLOC_INTERNAL_EDATA_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jem"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/edata_cache.h",
    "chars": 1610,
    "preview": "#ifndef JEMALLOC_INTERNAL_EDATA_CACHE_H\n#define JEMALLOC_INTERNAL_EDATA_CACHE_H\n\n#include \"jemalloc/internal/base.h\"\n\n/*"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/ehooks.h",
    "chars": 13874,
    "preview": "#ifndef JEMALLOC_INTERNAL_EHOOKS_H\n#define JEMALLOC_INTERNAL_EHOOKS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"j"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/emap.h",
    "chars": 13313,
    "preview": "#ifndef JEMALLOC_INTERNAL_EMAP_H\n#define JEMALLOC_INTERNAL_EMAP_H\n\n#include \"jemalloc/internal/base.h\"\n#include \"jemallo"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/emitter.h",
    "chars": 13967,
    "preview": "#ifndef JEMALLOC_INTERNAL_EMITTER_H\n#define JEMALLOC_INTERNAL_EMITTER_H\n\n#include \"jemalloc/internal/ql.h\"\n\ntypedef enum"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/eset.h",
    "chars": 2353,
    "preview": "#ifndef JEMALLOC_INTERNAL_ESET_H\n#define JEMALLOC_INTERNAL_ESET_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemal"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/exp_grow.h",
    "chars": 1421,
    "preview": "#ifndef JEMALLOC_INTERNAL_EXP_GROW_H\n#define JEMALLOC_INTERNAL_EXP_GROW_H\n\ntypedef struct exp_grow_s exp_grow_t;\nstruct "
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/extent.h",
    "chars": 4770,
    "preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_H\n#define JEMALLOC_INTERNAL_EXTENT_H\n\n#include \"jemalloc/internal/ecache.h\"\n#include \"j"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/extent_dss.h",
    "chars": 728,
    "preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_DSS_H\n#define JEMALLOC_INTERNAL_EXTENT_DSS_H\n\ntypedef enum {\n\tdss_prec_disabled  = 0,\n\t"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/extent_mmap.h",
    "chars": 328,
    "preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n\nextern bool opt_retain;"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/fb.h",
    "chars": 11286,
    "preview": "#ifndef JEMALLOC_INTERNAL_FB_H\n#define JEMALLOC_INTERNAL_FB_H\n\n/*\n * The flat bitmap module.  This has a larger API rela"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/fxp.h",
    "chars": 4013,
    "preview": "#ifndef JEMALLOC_INTERNAL_FXP_H\n#define JEMALLOC_INTERNAL_FXP_H\n\n/*\n * A simple fixed-point math implementation, support"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/hash.h",
    "chars": 8123,
    "preview": "#ifndef JEMALLOC_INTERNAL_HASH_H\n#define JEMALLOC_INTERNAL_HASH_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * The foll"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/hook.h",
    "chars": 5543,
    "preview": "#ifndef JEMALLOC_INTERNAL_HOOK_H\n#define JEMALLOC_INTERNAL_HOOK_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/*\n * This API is"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/hpa.h",
    "chars": 5018,
    "preview": "#ifndef JEMALLOC_INTERNAL_HPA_H\n#define JEMALLOC_INTERNAL_HPA_H\n\n#include \"jemalloc/internal/exp_grow.h\"\n#include \"jemal"
  },
  {
    "path": "deps/jemalloc/include/jemalloc/internal/hpa_hooks.h",
    "chars": 513,
    "preview": "#ifndef JEMALLOC_INTERNAL_HPA_HOOKS_H\n#define JEMALLOC_INTERNAL_HPA_HOOKS_H\n\ntypedef struct hpa_hooks_s hpa_hooks_t;\nstr"
  }
]

// ... and 1550 more files (download for full content)