Pith. sign in

REVIEW 2 major objections 4 minor 108 references

Succinct and Fast Tiny Pointer Hash Tables

T0 review · 2 major / 4 minor · reviewed 2026-08-03 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that two theoretical techniques, tiny pointers and quotienting, can be engineered into practical hash tables, yielding a chained design whose memory footprint drops below the raw size of the stored key-value pairs while op

desk verdict A credible practical succinct hash table that deserves referee time; the main weakness is that the dereference table's load factor isn't validated on the address-derived IDs the design actually uses. read the letter →

arxiv 2607.28892 v1 pith:JSQDR23X submitted 2026-07-30 cs.DS

Xilin Tang (Cornell University) , Yuqi Mai (Cornell University) , William Kuszmaul (Carnegie Mellon University) , Alex Conway (Cornell Tech) This is my paper · ORCID
classification cs.DS MSC 68P0568P20
keywords hashtablessuccinctdatastructurestinypointersquotientingdereferencetablespaceefficiencycachelocalitydynamicresizing
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that two theoretical compression ideas, tiny pointers (shrinking a 64-bit address to one byte via a dereference table) and quotienting (hiding part of each key in its hash location via a one-round Feistel permutation), can be turned into production-ready hash tables. The result is Chained-TPHT, a chained hash table whose footprint can fall below the size of the stored key-value data while preserving expected constant-time insert, delete, and query operations, and Flattened-TPHT, a cache-line-oriented variant that keeps the common case to a single cache miss. A reader should care because memory, not raw speed, is often the binding constraint in large in-memory systems, and conventional hash tables waste significant DRAM on pointers and metadata. If these claims hold, succinct hash tables move from a theoretical curiosity to a practical option with a measured space efficiency above 100% for Chained-TPHT and 83.4% for Flattened-TPHT.

What carries the argument

Key machinery: (1) Tiny pointers with a dereference table, a fixed-size allocator that returns an 8-bit pointer (a direction bit plus a bin index) instead of a 64-bit address, where dereferencing is a pure computation and power-of-two choices keep allocation failure negligible at 98.2% load. (2) One-round Feistel quotienting, a hash construction that splits each key k = q_pre ∘ r into a stored remainder r and a quotient q = h(r) ⊕ q_pre, so log n bits per key never need to be stored and the full key can be recovered as (q ⊕ h(r)) ∘ r. These two mechanisms work together to shrink the chained table's head array by a factor of eight and keep chains short, which is what allows the footprint to f

What would settle it

Run a sustained workload at 98.2% dereference-table load using keys deliberately chosen to make their bin addresses cluster, and count Allocate failures: a single failure at the claimed load, or a failure probability above the predicted negligible rate over polynomially many operations, would falsify the practical-succinctness claim. One can also check directly whether the address-derived IDs remain uniformly distributed across bins under different allocator layouts.

Watch

Extended reading notes

Core claim

The paper's central claim is that Chained-TPHT is, to its authors' knowledge, the first simple and practical succinct hash table: for n pairs of w-bit keys and values, it uses approximately n(2w - log n + 8 + 16/127)/(1 - delta) + 8n bits, which in the standard parameter regime w = O(log n) is within a (1+o(1)) factor of the information-theoretic lower bound while supporting O(1) expected-time operations. This is achieved by storing every pointer as an 8-bit tiny pointer through a dereference table and storing only the remainder of each key after quotienting away its high-order bits. The paper further claims Flattened-TPHT reaches 83.4% space efficiency with up to 89.3% higher throughput tha

Load-bearing premise

The load-bearing premise is that the dereference table's two-choice bin allocation keeps every bin far enough from full when the tiny-pointer IDs are simply the addresses of the pointer fields; this is verified empirically on random keys and insert/delete mixes, but not analyzed or tested for adversarial or highly skewed key patterns, and if a bin ever fills, Allocate fails and the hash table returns an error by design.

Editorial extensions

If this is right

  • Chained-TPHT's head array shrinks by a factor of eight, so a large table's head array can fit in cache and most lookups complete in a single probe.
  • Quotienting saves log n bits per key, which is enough to push total memory below the raw size of the stored key-value pairs.
  • The two-choice dereference table at 98.2% load gives a practical instantiation of tiny pointers with no extra memory access on dereference.
  • The resizing framework divides growth into collaborative strides, avoiding stop-the-world pauses while keeping worst-case space efficiency at 46.7% with staggering.
  • Flattened-TPHT's home-block layout bounds operations to at most three cache misses outside resizing, with an average near 1.25, giving a strong tail-latency profile.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • [Editorial inference] The address-as-ID trick means the dereference table's hash inputs are the in-memory addresses of tiny-pointer fields; since allocators and layout choices shape those addresses, a workload that skews which bins those addresses hash to could stress the bin balance and trigger the allocation-failure path.
  • [Editorial inference] The pairing of tiny pointers and Feistel quotienting could plausibly transfer to other pointer-heavy structures, such as linked lists, tries, or adjacency lists, wherever per-node metadata dwarfs payload.
  • [Editorial inference] Supporting variable-length keys and values would require an extra indirection to the actual payload, adding a memory access and partially offsetting the space gain; the paper notes this extension but does not measure it.
  • [Editorial inference] A natural stress test is to run adversarial key distributions at 98% dereference-table load and watch for allocation-failure errors, which would reveal whether the 98.2% load factor is robust beyond the random-key and insert/delete mixes tested.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper presents Tiny Pointer Hash Tables (TPHT), two hash-table designs that combine tiny pointers (implemented via a dereference table) with one-round Feistel quotienting. Chained-TPHT targets maximal space efficiency and is claimed to be the first simple, practical succinct hash table, with footprint below the raw data size while supporting O(1) expected-time operations. Flattened-TPHT targets latency by using cache-line-sized home blocks and SIMD-accelerated fingerprint checks. Both support concurrency, deletions, and resizing. The evaluation uses YCSB and microbenchmarks against general and compact baselines, reporting that Chained-TPHT achieves 105.4% space efficiency and Flattened-TPHT achieves 83.4% space efficiency while improving throughput. The theoretical space analysis in Section 5.3 derives a formula approaching the information-theoretic lower bound in the regime w=O(log n).

Significance. If the central claims are correct, this is a significant advance: it would demonstrate that succinct hash tables with constant-time operations can be practical, and that a hash table can store 64-bit key-value pairs in less memory than the raw pairs occupy. The paper ships source code, uses a broad set of baselines, and gives explicit space formulas tied to an information-theoretic lower bound. The main risk is that the space-efficiency claims depend on the dereference table achieving a 98.2% load factor under the specific ID distribution used in the actual hash table (the address of the tiny-pointer field). The paper's capacity test in Section 8.6 does not clearly establish this. A second, more localized issue is a numerical error in the failure-rate analysis in Section 6.4. Both are fixable with additional experiments/analysis; the overall design is plausible and the empirical scope is substantial.

major comments (2)
  1. [Sections 3.3, 5.1, 8.6] The load-bearing space claim rests on the dereference table operating at load factor 1−δ with δ≈2%, but Section 8.6 does not validate this for the actual ID distribution used by Chained-TPHT. In Sections 3.3 and 5.1, the ID k passed to Allocate/Dereference is the in-memory address of the tiny-pointer field that references the node. These IDs are not i.i.d. random: head-array IDs are consecutive byte addresses, and node p-field IDs are spaced by the slot size and depend on the entire prior allocation history through the two-choice process. The capacity experiment in Section 8.6 is described only as 'random insertions' and 'alternating random insertions and deletions' without stating what IDs were used. If those experiments used random IDs rather than the address-derived IDs, the reported 98.2%/95% load factors do not transfer to the real system. This matters directly for Section 5.3: with
  2. [Section 6.4, Claim 4] The numerical assertion that the Azuma deviation is 'below 1% of the dataset size' for n≥10^5 is arithmetically incorrect. With λ=2√(2n ln n), for n=10^5 we have λ≈3035, which is about 3% of n; for n=10^6, λ≈10500, still above 1% of n. The threshold should be around n≳1.1×10^6. This affects the statement that the dereference table for Flattened-TPHT is 'conservatively sized' at the indicated dataset sizes. Please correct the threshold or the claimed deviation, and adjust any sizing guidance that relies on it.
minor comments (4)
  1. [Section 3.2] The caption says 'Meta table (2n bytes)', but with bins of 2^7−1 slots and a data table of ≈n entries, the meta table should be 2(n/127) bytes = 16n/127 bits, matching the formula in Section 5.3. Please correct the inconsistency.
  2. [Section 5.2] The probability statement is reversed. If 2^ℓ ≥ n, then n/2^ℓ ≤ 1 and 1−e^{−n/2^ℓ} ≤ 1−e^{−1} ≈ 63.2%, not ≥ 63.2%. Rephrase to say that the probability a lookup finds a singleton chain is at most this value, or adjust the condition to 2^ℓ = n for the claimed lower bound.
  3. [Section 4.1, Claim 2] The claim that the indicators X_i^(b) are negatively associated is asserted without proof, with a general citation [94] rather than a derivation for the Feistel-constructed family. Since this underlies the theoretical max-load bound, a short justification or a more specific reference would strengthen the claim. The empirical results in Section 8.7 provide some practical support.
  4. [Section 8] Throughput numbers are reported as single-point measurements without error bars or repeated-run statistics. Given the precise percentage comparisons (e.g., 89.3% higher throughput), reporting variance or at least multiple runs would make the empirical claims more robust.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the space and performance claims are assembled from standard lower bounds, published independent theory, measured engineering parameters, and external baselines; the address-ID load-factor concern is an extrapolation gap, not a circular reduction.

full rationale

Chained-TPHT's space formula (Sec. 5.3) is assembled from the value size w, the quotiented remainder of length w−log n, an 8-bit tiny pointer, meta-table overhead 16/127 bits, head-array overhead 8n, divided by 1−δ, where δ≈2% is taken from the dereference-table capacity experiment (Sec. 8.6). This is a measured engineering parameter used in the space calculation, not a restatement of the target claim: the formula does not reduce to the experiment by construction. The asymptotic succinctness statement invokes the prior tiny-pointers theorem [12], but that theorem is published, parameterized, and independent of this paper's implementation details; it is not an ansatz smuggled in by citation, nor is it used as a uniqueness theorem to forbid alternatives. The quotienting claims rest on the Feistel construction and standard Chernoff/balls-into-bins arguments developed in Sec. 4, with explicit proofs, rather than on the hash table's own measured behavior. Reported throughput and space-efficiency numbers are measured against external baselines and YCSB workloads. The skeptic note identifies a real but non-circular gap: Sec. 8.6 reports 'random insertions' without stating the ID distribution, while Chained-TPHT uses addresses of pointer fields as IDs (Sec. 3.3), and Sec. 7.2 says failures return an error. That is an unvalidated extrapolation and a robustness risk, not a step where an equation or fitted parameter is renamed as a prediction.

Assumptions & free parameters 2 free parameters · 5 assumptions · 0 invented entities

The central claims rest on: (a) an empirically measured dereference-table load factor (98.2% insertion-only, 95% alternating) that sets the (1-delta) denominator in the space formulas; (b) standard balls-and-bins/negative-association/Azuma tools used to argue failures and overflows are negligible; and (c) a Poisson(4) approximation for home-block loads. No new physical or algorithmic entities are postulated beyond the engineering structure; the tiny-pointer dereference table is an implementation of a known theoretical construction [12].

free parameters (2)
  • Dereference table load factor (insertion-only) = 98.2%
    Measured in Section 8.6; used as (1-delta) in the space formula in Section 5.3 to derive 105.4% space efficiency. Not guaranteed by the two-choice analysis; varies with workload (95% with deletions).
  • Dereference table load factor (alternating insert/delete) = 95%
    Measured in Section 8.6 for 100x capacity alternating workloads; the headline space-efficiency claims use the insertion-only number, so the more conservative value is a fitted input for workloads with deletions.
assumptions (5)
  • domain assumption Two-choice hashing balances balls into bins so that no bin exceeds load + log log b + O(1) w.h.p., preventing dereference-table allocation failure at 98.2% load.
    Invoked in Section 3.2 to justify the practical dereference table. Relies on balls-and-bins theory [7,9,17,88]; the constant 98.2% is empirical.
  • standard math The one-round Feistel hash family H_q is universal and its occupancy indicators are negatively associated, so Chernoff bounds give max load Theta(log n/log log n).
    Claims 1-2 in Section 4.1; Claim 2 cites negative association [94] without proving negative association for this construction.
  • domain assumption Home-block loads are well-approximated by Poisson(4), and overflow follows O = max(0, x-4+floor(x/6)).
    Used in Section 6.4 to size the dereference table; the paper validates Poisson occupancy for four key distributions in Section 8.7 but assumes the approximation for all workloads.
  • standard math Azuma-Hoeffding applies to total overflow with martingale differences bounded by 2.
    Claim 4 in Section 6.4; the stated tail bound is numerically mis-stated in the text.
  • standard math Each home block can store up to 31 tiny pointers after full migration; max bin load < 24 for n < 2^64, so hard overflow never occurs w.h.p.
    Section 6.4 applies the Raab-Steger max-bin-load lemma [82].

how reviews work

0 comments
Cite this review

Pith. "Pith review of Succinct and Fast Tiny Pointer Hash Tables." pith.science (2026). https://pith.science/paper/JSQDR23X

@misc{pith2026260728892,
  author       = {Pith},
  title        = {Pith review of: Succinct and Fast Tiny Pointer Hash Tables},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JSQDR23X}},
  note         = {Machine review of arXiv:2607.28892}
}
read the original abstract

Hash tables sit on the critical path of many systems, yet modern designs still force a trade-off between fast operations and high memory overhead. We revisit this trade-off and present Tiny Pointer Hash Tables (TPHT), a family of practical hash tables that make two ideas from theory work at system scale: compressing pointers down to a byte, and encoding keys compactly so less metadata is needed. We engineer these ideas into two complementary designs. Chained-TPHT targets maximal space savings, and is to the best of our knowledge the first simple and practical succinct hash table design, achieving a footprint less than the total data size with constant-time operations. Flattened-TPHT targets latency, organizing data to keep the common case within a single cache miss while retaining strong space efficiency. Both variants support dynamic resizing without global pauses and integrate cleanly with 64-bit keys and values. Across YCSB and microbenchmarks, TPHT advances the latency-space Pareto frontier: Chained-TPHT reaches 105.4% space efficiency, and Flattened-TPHT achieves 83.4% space efficiency with up to 89.3% higher throughput than strong baselines. Together, these results show that techniques primarily known in theory can be turned into production-ready hash tables that meaningfully reduce memory use while delivering state-of-the-art performance.

Figures

Figures reproduced from arXiv: 2607.28892 by the authors.

Figure 1
Figure 1. Meta layout, data bins, and the steps of [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Query for key 𝑘 in the chained hash table with tiny pointers. The direction bit of the first tiny pointer is 1 in this example, and leads to the bin corresponding to ℎ1 (𝐴ℎ(𝑘)) in our dereference table implementation. The meta table is not used during queries. 4 Quotienting The idea behind quotienting is to use the bin index to implicitly store part of each key. If the keys themselves are random or if it’s sufficien… view at source ↗
Figure 3
Figure 3. Quotienting pipeline: the hash determines the quo [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: Flattened Data Layout of Flattened-TPHT Dereference table sizing analysis. Let 𝑂 denote the number of overflow tuples in an arbitrary home block. By linearity of expecta￾tion, the expected total number of overflow tuples is (𝑛/4)E[𝑂]. If a home block has 𝑥 tuples, then…
Figure 5
Figure 5. Figure 5: Performance of hash tables on YCSB workloads with 16 threads. (Throughput is Million ops/second). [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Throughput-space efficiency tradeoff across insertion and query workloads. Each curve shows how throughput and [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Throughput-space efficiency tradeoff for compact hash tables. [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Performance scaling analysis for hash tables with increasing dataset size, single-threaded. [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 9
Figure 9. Figure 9: Performance of hash tables on YCSB workloads with 16 threads (resizing enabled). 0 20 40 60 80 100 0 50 100 150 Window Throughput (M/s) [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 12
Figure 12. Figure 12: Load factor sup￾ported by dereference tables (Section 3.2). 0 1 3 5 7 9 11 10−1 10−3 10−5 10−7 10−9 Poisson(𝜆 = 1) Bin Occupancy Relative Frequency Random Sequential Low Hamming High Hamming [PITH_FULL_IMAGE:figures/full_fig_p013_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

108 extracted references · 10 canonical work pages

  1. [12]

    Bender, Alex Conway, Martin Farach-Colton, William Kuszmaul, and Guido Tagliavini

    Michael A. Bender, Alex Conway, Martin Farach-Colton, William Kuszmaul, and Guido Tagliavini. 2023. Tiny Pointers. InProceedings of the 2023 ACM- SIAM Symposium on Discrete Algorithms, SODA 2023, Florence, Italy, January 22-25, 2023, Nikhil Bansal and Viswanath Nagarajan (Eds.). SIAM, 477–508. https://doi.org/10.1137/1.9781611977554.CH21

    work page doi:10.1137/1.9781611977554.ch21 2023

  2. [1]

    Michael Abebe, Brad Glasbergen, and Khuzaima Daudjee. 2020. MorphoSys: automatic physical design metamorphosis for distributed database systems. Proceedings of the VLDB Endowment13, 13 (2020), 3573–3587

    2020

  3. [2]

    Abseil. 2024. Swiss Tables Design Notes. https://abseil.io/about/design/ swisstables

    2024

  4. [3]

    Ahmed Alquraan, Alex Kogan, Virendra J Marathe, and Samer Al-Kiswany. 2020. Scalable, near-zero loss disaster recovery for distributed data stores.Proceedings of the VLDB Endowment13, 9 (2020), 1429–1442

    2020

  5. [4]

    Yuriy Arbitman, Moni Naor, and Gil Segev. 2009. Backyard Cuckoo Hashing: Constant Worst-Case Operations with a Succinct Representation.2010 IEEE 51st Annual Symposium on Foundations of Computer Science(2009), 787–796. https://api.semanticscholar.org/CorpusID:5544423 Xilin Tang, Yuqi Mai, William Kuszmaul, and Alex Conway

    2009

  6. [5]

    Rizwan A Ashraf, Roberto Gioiosa, Gokcen Kestor, Ronald F DeMara, Chen- Yong Cher, and Pradip Bose. 2015. Understanding the propagation of transient errors in HPC applications. InProceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. 1–12

    2015

  7. [6]

    Bender, Martín Farach-Colton, Rotem Oshman, and Noa Schiller

    Hagit Attiya, Michael A. Bender, Martín Farach-Colton, Rotem Oshman, and Noa Schiller. 2025. History-Independent Concurrent Hash Tables. arXiv:2503.21016 [cs.DC]

    arXiv 2025

  8. [7]

    Broder, Anna R

    Yossi Azar, Andrei Z. Broder, Anna R. Karlin, and Eli Upfal. 1999. Balanced Allocations.SIAM J. Comput.29, 1 (1999), 180–200. https://doi.org/10.1137/ S0097539795288490 arXiv:https://doi.org/10.1137/S0097539795288490

    work page doi:10.1137/s0097539795288490 1999

Show all 108 references
  1. [8]

    Baeldung. 2024. Guide to hashMap Load Factor. https://www.baeldung.com/ java-hashmap-load-factor Accessed: 2024-12-19

    2024

  2. [9]

    Nikhil Bansal and William Kuszmaul. 2022. Balanced Allocations: The Heavily Loaded Case with Deletions. arXiv:2205.06558 [cs.DS] https://arxiv.org/abs/ 2205.06558

    2022 arXiv

  3. [10]

    Botelho, and Martin Dietzfelbinger

    Djamal Belazzougui, Fabiano C. Botelho, and Martin Dietzfelbinger. 2009. Hash, Displace, and Compress. InEmbedded Systems and Applications. https://api. semanticscholar.org/CorpusID:15109149

    2009

  4. [11]

    Bender, Alex Conway, Martín Farach-Colton, William Kuszmaul, and Guido Tagliavini

    Michael A. Bender, Alex Conway, Martín Farach-Colton, William Kuszmaul, and Guido Tagliavini. 2023. Iceberg Hashing: Optimizing Many Hash-Table Criteria at Once.J. ACM70, 6, Article 40 (Nov. 2023), 51 pages. https://doi. org/10.1145/3625817

    2023 doi

  5. [13]

    Bender, Martin Farach-Colton, Rob Johnson, Russell Kraner, Bradley C

    Michael A. Bender, Martin Farach-Colton, Rob Johnson, Russell Kraner, Bradley C. Kuszmaul, Dzejla Medjedovic, Pablo Montes, Pradeep Shetty, Richard P. Spillane, and Erez Zadok. 2012. Don’t thrash: how to cache your hash on flash.Proc. VLDB Endow.5, 11 (July 2012), 1627–1637. h...

    2012

  6. [14]

    Michael A Bender, Martín Farach-Colton, John Kuszmaul, and William Kusz- maul. 2024. Modern hashing made simple. In2024 Symposium on Simplicity in Algorithms (SOSA). SIAM, 363–373

    2024

  7. [15]

    Bender, Martín Farach-Colton, John Kuszmaul, William Kuszmaul, and Mingmou Liu

    Michael A. Bender, Martín Farach-Colton, John Kuszmaul, William Kuszmaul, and Mingmou Liu. 2022. On the optimal time/space tradeoff for hash tables. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing (Rome, Italy)(STOC 2022). Association for Computin...

    2022

  8. [16]

    Bender, Bradley C

    Michael A. Bender, Bradley C. Kuszmaul, and William Kuszmaul. 2022. Linear Probing Revisited: Tombstones Mark the Demise of Primary Clustering. In 2021 IEEE 62nd Annual Symposium on Foundations of Computer Science (FOCS). 1171–1182. https://doi.org/10.1109/FOCS52979.2021.00115

    2022

  9. [17]

    Petra Berenbrink, Artur Czumaj, Angelika Steger, and Berthold Vöcking. 2006. Balanced Allocations: The Heavily Loaded Case.SIAM J. Comput.35, 6 (June 2006), 1350–1385. https://doi.org/10.1137/S009753970444435X

    2006 doi

  10. [18]

    Botelho, Rasmus Pagh, and Nivio Ziviani

    Fabiano C. Botelho, Rasmus Pagh, and Nivio Ziviani. 2007. Simple and space- efficient minimal perfect hash functions. InProceedings of the 10th International Conference on Algorithms and Data Structures(Halifax, Canada)(W ADS’07). Springer-Verlag, Berlin, Heidelberg, 139–150

    2007

  11. [19]

    Mark Braverman and William Kuszmaul. 2024. Tight Analyses of Ordered and Unordered Linear Probing. In2024 IEEE 65th Annual Symposium on Foundations of Computer Science (FOCS). IEEE, 606–635

    2024

  12. [20]

    Breslow, Dong Ping Zhang, Joseph L

    Alex D. Breslow, Dong Ping Zhang, Joseph L. Greathouse, Nuwan Jayasena, and Dean M. Tullsen. 2016. Horton Tables: Fast Hash Tables for In-Memory Data- Intensive Computing. In2016 USENIX Annual Technical Conference (USENIX ATC 16). USENIX Association, Denver, CO, 281–294. https...

    2016

  13. [21]

    Andrei Z Broder, Moses Charikar, Alan M Frieze, and Michael Mitzenmacher

  14. [22]

    Maximilian Böther, Lawrence Benson, Ana Klimović, and Tilmann Rabl. 2023. Analyzing Vectorized Hash Tables Across CPU Architectures. InProceedings of the VLDB Endowment (VLDB ’23)

    2023

  15. [23]

    Badrish Chandramouli, Guna Prasaad, Donald Kossmann, Justin Levandoski, James Hunter, and Mike Barnett. 2018. FASTER: A Concurrent Key-Value Store with In-Place Updates. InProceedings of the 2018 International Conference on Management of Data(Houston, TX, USA)(SIGMOD ’18). Ass...

    2018

  16. [24]

    Phillips, and Prashant Pandey

    Yuvaraj Chesetti, Benwei Shi, Jeff M. Phillips, and Prashant Pandey. 2025. Zom- bie Hashing: Reanimating Tombstones in Graveyard.Proc. ACM Manag. Data3, 3, Article 236 (June 2025), 27 pages. https://doi.org/10.1145/3725424

    2025 doi

  17. [25]

    J. G. Clerry. 1984. Compact Hash Tables Using Bidirectional Linear Probing. IEEE Trans. Comput.33, 9 (Sept. 1984), 828–834. https://doi.org/10.1109/TC. 1984.1676499

    1984

  18. [26]

    Yann Collet. 2024. xxHash: Extremely fast non-cryptographic hash algorithm. Online documentation and reference implementation. https://xxhash.com/ Available in multiple programming languages

    2024

  19. [27]

    Cooper, Adam Silberstein, Erwin Tam, Raghu Ramakrishnan, and Rus- sell Sears

    Brian F. Cooper, Adam Silberstein, Erwin Tam, Raghu Ramakrishnan, and Rus- sell Sears. 2010. Benchmarking cloud serving systems with YCSB. InProceedings of the 1st ACM Symposium on Cloud Computing(Indianapolis, Indiana, USA) (SoCC ’10). Association for Computing Machinery, New...

    2010

  20. [28]

    Tudor David, Rachid Guerraoui, and Vasileios Trigonakis. 2015. Asynchro- nized Concurrency: The Secret to Scaling Concurrent Search Data Struc- tures.SIGARCH Comput. Archit. News43, 1 (March 2015), 631–644. https: //doi.org/10.1145/2786763.2694359

    2015

  21. [29]

    Tudor David, Rachid Guerraoui, and Vasileios Trigonakis. 2015. Asynchronized Concurrency: The Secret to Scaling Concurrent Search Data Structures. In Proceedings of the Twentieth International Conference on Architectural Support for Programming Languages and Operating Systems(...

    2015

  22. [30]

    David J DeWitt, Randy H Katz, Frank Olken, Leonard D Shapiro, Michael R Stonebraker, and David A Wood. 1984. Implementation techniques for main memory database systems. InProceedings of the 1984 ACM SIGMOD international conference on management of data. 1–8

    1984

  23. [31]

    Martin Dietzfelbinger, Anna Karlin, Kurt Mehlhorn, Friedhelm Meyer auf der Heide, Hans Rohnert, and Robert E. Tarjan. 1994. Dynamic Perfect Hashing: Upper and Lower Bounds.SIAM J. Comput.23, 4 (1994), 738–761. https://doi.org/ 10.1137/S0097539791194094 arXiv:https://doi.org/10...

    1994 doi

  24. [32]

    Köppl Dominik. 2019. , 11 pages. https://ipsj.ixsq.nii.ac.jp/api/records/195522

    2019

  25. [33]

    Tomer Even, Guy Even, and Adam Morrison. 2022. Prefix filter: practically and theoretically better than bloom.Proc. VLDB Endow.15, 7 (March 2022), 1311–1323. https://doi.org/10.14778/3523210.3523211

    2022

  26. [34]

    Facebook. 2023. Folly: An open-source C++ library developed and used at Facebook. https://github.com/facebook/folly

    2023

  27. [35]

    Andersen, and Michael Kaminsky

    Bin Fan, David G. Andersen, and Michael Kaminsky. 2013. MemC3: compact and concurrent MemCache with dumber caching and smarter hashing. In Proceedings of the 10th USENIX Conference on Networked Systems Design and Implementation(Lombard, IL)(nsdi’13). USENIX Association, USA, 371–384

    2013

  28. [36]

    Martin Farach-Colton, Andrew Krapivin, and William Kuszmaul. 2025. Optimal Bounds for Open Addressing Without Reordering. arXiv:2501.02305 [cs.DS] https://arxiv.org/abs/2501.02305

    2025 arXiv

  29. [37]

    Philippe Flajolet, Patricio Poblete, and Alfredo Viola. 1998. On the analysis of linear probing hashing.Algorithmica22, 4 (1998), 490–515

    1998

  30. [38]

    Fredman, János Komlós, and Endre Szemerédi

    Michael L. Fredman, János Komlós, and Endre Szemerédi. 1984. Storing a Sparse Table with 0(1) Worst Case Access Time.J. ACM31, 3 (June 1984), 538–544. https://doi.org/10.1145/828.1884

    1984 doi

  31. [39]

    Hector Garcia-Molina and Kenneth Salem. 2002. Main memory database sys- tems: An overview.IEEE Transactions on knowledge and data engineering4, 6 (2002), 509–516

    2002

  32. [40]

    Rémi Géraud, Marius Lombard-Platet, and David Naccache. 2019. Quotient hash tables: efficiently detecting duplicates in streaming data. InProceedings of the 34th ACM/SIGAPP Symposium on Applied Computing(Limassol, Cyprus) (SAC ’19). Association for Computing Machinery, New Yor...

    2019

  33. [41]

    Andersen, and Michael Kaminsky

    Manu Goyal, Bin Fan, Xiaozhou Li, David G. Andersen, and Michael Kaminsky

  34. [42]

    Leo J Guibas and Endre Szemeredi. 1976. The analysis of double hashing. InProceedings of the eighth annual ACM symposium on Theory of computing. 187–191

    1976

  35. [43]

    Steef Hegeman, Daan Wöltgens, Anton Wijs, and Alfons Laarman. 2024. Com- pact Parallel Hash Tables on GPU. InEuro-Par 2024: Parallel Processing: 30th European Conference on Parallel and Distributed Processing, Madrid, Spain, Au- gust 26-30, 2024, Proceedings, Part II(Madrid, S...

    2024 doi

  36. [44]

    Daokun Hu, Zhiwen Chen, Wenkui Che, Jianhua Sun, and Hao Chen. 2022. Halo: A Hybrid PMem-DRAM Persistent Hash Index with Fast Recovery. InProceed- ings of the 2022 International Conference on Management of Data(Philadelphia, PA, USA)(SIGMOD ’22). Association for Computing Mach...

    2022

  37. [45]

    Daokun Hu, Zhiwen Chen, Jianbing Wu, Jianhua Sun, and Hao Chen. 2021. Persistent memory hash indexes: an experimental evaluation.Proc. VLDB Endow. 14, 5 (Jan. 2021), 785–798. https://doi.org/10.14778/3446095.3446101

    2021

  38. [46]

    Yu Hua, Hong Jiang, and Dan Feng. 2014. FAST: Near real-time searchable data analytics for the cloud. InSC’14: Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE, 754–765

    2014

  39. [47]

    Intel®. 2021. Intel®oneAPI Threading Building Blocks (oneTBB). https://www.intel.com/content/www/us/en/docs/onetbb/developer-guide- api-reference/2021-9/concurrent-hash-map.html Accessed: 2025-10-21

    2021

  40. [48]

    Zsolt István, Gustavo Alonso, Michaela Blott, and Kees Vissers. 2015. A Hash Table for Line-Rate Data Processing.ACM Trans. Reconfigurable Technol. Syst. Succinct and Fast Tiny Pointer Hash Tables 8, 2, Article 13 (March 2015), 15 pages. https://doi.org/10.1145/2629582

    2015 doi

  41. [49]

    Patel, Brian P

    Aarati Kakaraparthy, Jignesh M. Patel, Brian P. Kroth, and Kwanghyun Park

  42. [50]

    Antonios Katsarakis, Vasilis Gavrielatos, and Nikos Ntarmos. 2024. DLHT: A non-blocking resizable hashtable with fast deletes and memory-awareness. In Proceedings of the 33rd International Symposium on High-Performance Parallel and Distributed Computing. 186–199

    2024

  43. [51]

    Pearlmutter, and Phil Maguire

    Robert Kelly, Barak A. Pearlmutter, and Phil Maguire. 2018. Concurrent Robin Hood Hashing. arXiv:1809.04339 [cs.DC] https://arxiv.org/abs/1809.04339

    2018 arXiv

  44. [52]

    Donald E. Knuth. 1998.The art of computer programming, volume 3: (2nd ed.) sorting and searching. Addison Wesley Longman Publishing Co., Inc., USA

    1998

  45. [53]

    Puglisi, and Rajeev Raman

    Dominik Köppl, Simon J. Puglisi, and Rajeev Raman. 2022. Fast and Simple Compact Hashing via Bucketing.Algorithmica84, 9 (Sept. 2022), 2735–2766. https://doi.org/10.1007/s00453-022-00996-y

    2022 doi

  46. [54]

    Florian Kurpicz, Hans-Peter Lehmann, and Peter Sanders. 2022. PaCHash: Packed and Compressed Hash Tables.ArXivabs/2205.04745 (2022). https: //api.semanticscholar.org/CorpusID:248666009

    2022 arXiv

  47. [55]

    William Kuszmaul and Zoe Xi. 2024. Towards an Analysis of Quadratic Probing. In51st International Colloquium on Automata, Languages, and Programming (ICALP 2024). Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 103–1

    2024

  48. [56]

    Shir Landau-Feibish, Zaoxing Liu, and Jennifer Rexford. 2025. Compact Data Structures for Network Telemetry.ACM Comput. Surv.57, 8, Article 191 (March 2025), 31 pages. https://doi.org/10.1145/3716819

    2025 doi

  49. [57]

    Christoph Lenzen, Merav Parter, and Eylon Yogev. 2019. Parallel Balanced Allocations: The Heavily Loaded Case. InThe 31st ACM Symposium on Par- allelism in Algorithms and Architectures(Phoenix, AZ, USA)(SPAA ’19). As- sociation for Computing Machinery, New York, NY, USA, 313–3...

    2019

  50. [58]

    Bojie Li, Zhenyuan Ruan, Wencong Xiao, Yuanwei Lu, Yongqiang Xiong, Andrew Putnam, Enhong Chen, and Lintao Zhang. 2017. KV-Direct: High- Performance In-Memory Key-Value Store with Programmable NIC. InProceed- ings of the 26th Symposium on Operating Systems Principles(Shanghai,...

    2017

  51. [59]

    Zexuan Li and Kaixin Huang. 2024. A read-efficient and write-optimized hash table for Intel Optane DC Persistent Memory.Future Generation Computer Systems161 (2024), 49–65

    2024

  52. [60]

    Andersen, and Michael Kaminsky

    Hyeontaek Lim, Bin Fan, David G. Andersen, and Michael Kaminsky. 2011. SILT: a memory-efficient, high-performance key-value store. InProceedings of the Twenty-Third ACM Symposium on Operating Systems Principles(Cascais, Portugal)(SOSP ’11). Association for Computing Machinery,...

    2011

  53. [61]

    Andersen, and Michael Kaminsky

    Hyeontaek Lim, Dongsu Han, David G. Andersen, and Michael Kaminsky. 2014. MICA: a holistic approach to fast in-memory key-value storage. InProceedings of the 11th USENIX Conference on Networked Systems Design and Implementation (Seattle, WA)(NSDI’14). USENIX Association, USA, 429–444

    2014

  54. [62]

    Ravishankar

    Ming-Ling Lo and Chinya V. Ravishankar. 1996. Spatial hash-joins. InProceed- ings of the 1996 ACM SIGMOD International Conference on Management of Data (Montreal, Quebec, Canada)(SIGMOD ’96). Association for Computing Machin- ery, New York, NY, USA, 247–258. https://doi.org/10...

    1996

  55. [63]

    2022.Bal- anced Allocations: Caching and Packing, Twinning and Thin- ning

    Dimitrios Los, Thomas Sauerwald, and John Sylvester. 2022.Bal- anced Allocations: Caching and Packing, Twinning and Thin- ning. 1847–1874. https://doi.org/10.1137/1.9781611977073.74 arXiv:https://epubs.siam.org/doi/pdf/10.1137/1.9781611977073.74

    2022 doi

  56. [64]

    Baotong Lu, Xiangpeng Hao, Tianzheng Wang, and Eric Lo. 2020. Dash: scalable hashing on persistent memory.Proc. VLDB Endow.13, 8 (April 2020), 1147–1161. https://doi.org/10.14778/3389133.3389134

    2020

  57. [65]

    Baotong Lu, Xiangpeng Hao, Tianzheng Wang, and Eric Lo. 2021. Scaling Dynamic Hash Tables on Real Persistent Memory.SIGMOD Rec.50, 1 (June 2021), 87–94. https://doi.org/10.1145/3471485.3471506

    2021

  58. [66]

    Michael Luby and Charles Rackoff. 1988. How to Construct Pseudorandom Permutations from Pseudorandom Functions.SIAM J. Comput.17, 2 (1988), 373–386. https://doi.org/10.1137/0217022 arXiv:https://doi.org/10.1137/0217022

    1988 doi

  59. [67]

    Clemens Lutz, Sebastian Breß, Steffen Zeuch, Tilmann Rabl, and Volker Markl

  60. [68]

    Tobias Maier, Peter Sanders, and Roman Dementiev. 2019. Concurrent Hash Tables: Fast and General(?)!ACM Trans. Parallel Comput.5, 4, Article 16 (Feb. 2019), 32 pages. https://doi.org/10.1145/3309206

    2019 doi

  61. [69]

    Tobias Maier, Peter Sanders, and Stefan Walzer. 2019. Dynamic Space Efficient Hashing.Algorithmica81, 8 (Aug. 2019), 3162–3185. https://doi.org/10.1007/ s00453-019-00572-x

    2019

  62. [70]

    Memcached. 2009. Memcached. https://memcached.org/

    2009

  63. [71]

    InProceedings of the 2022 International Conference on Management of Data(Philadelphia, PA, USA)(SIGMOD ’22)

    Triton Join: Efficiently Scaling to a Large Join State on GPUs with Fast Interconnects. InProceedings of the 2022 International Conference on Management of Data(Philadelphia, PA, USA)(SIGMOD ’22). Association for Computing Machinery, New York, NY, USA, 1017–1032. https://doi.o...

    2022 doi

  64. [72]

    2005.Probability and Computing: Ran- domized Algorithms and Probabilistic Analysis

    Michael Mitzenmacher and Eli Upfal. 2005.Probability and Computing: Ran- domized Algorithms and Probabilistic Analysis. Cambridge University Press, USA

    2005

  65. [73]

    André Müller, Christian Hundt, Andreas Hildebrandt, Thomas Hankeln, and Bertil Schmidt. 2017. MetaCache: context-aware classification of metagenomic reads using minhashing.Bioinformatics33, 23 (2017), 3740–3748

    2017

  66. [74]

    Vikram Narayanan, David Detweiler, Tianjiao Huang, and Anton Burtsev. 2023. DRAMHiT: A Hash Table Architected for the Speed of DRAM. InProceedings of the Eighteenth European Conference on Computer Systems(Rome, Italy)(EuroSys ’23). Association for Computing Machinery, New York...

    2023

  67. [75]

    Menezes, Scott A

    Alfred J. Menezes, Scott A. Vanstone, and Paul C. Van Oorschot. 1996.Handbook of Applied Cryptography(1st ed.). CRC Press, Inc., USA

    1996

  68. [76]

    Rasmus Pagh and Flemming Friche Rodler. 2004. Cuckoo hashing.Journal of Algorithms51, 2 (2004), 122–144

    2004

  69. [77]

    Bender, Alex Conway, Martin Farach-Colton, William Kuszmaul, Guido Tagliavini, and Rob Johnson

    Prashant Pandey, Michael A. Bender, Alex Conway, Martin Farach-Colton, William Kuszmaul, Guido Tagliavini, and Rob Johnson. 2023. IcebergHT: High Performance Hash Tables Through Stability and Low Associativity.Proc. ACM Manag. Data1, 1, Article 47 (May 2023), 26 pages. https:/...

    2023

  70. [78]

    Bender, Martin Farach- Colton, and Rob Johnson

    Prashant Pandey, Alex Conway, Joe Durie, Michael A. Bender, Martin Farach- Colton, and Rob Johnson. 2021. Vector Quotient Filters: Overcoming the Time/Space Trade-Off in Filter Design. InProceedings of the 2021 Interna- tional Conference on Management of Data(Virtual Event, Ch...

    2021

  71. [79]

    Gonzalo Navarro and Veli Mäkinen. 2007. Compressed full-text indexes.ACM Comput. Surv.39, 1 (April 2007), 2–es. https://doi.org/10.1145/1216370.1216372

    2007

  72. [80]

    Puglisi, and Rajeev Raman

    Andreas Poyias, Simon J. Puglisi, and Rajeev Raman. 2017. m-Bonsai: a Practical Compact Dynamic Trie. arXiv:1704.05682 [cs.DS] https://arxiv.org/abs/1704. 05682

    2017 arXiv

  73. [81]

    Jeff Preshing. 2024. Junction: Concurrent data structures in C++. https:// github.com/preshing/junction. https://github.com/preshing/junction GitHub repository

    2024

  74. [82]

    Balls into Bins

    Martin Raab and Angelika Steger. 1998. "Balls into Bins" - A Simple and Tight Analysis. InProceedings of the Second International Workshop on Randomization and Approximation Techniques in Computer Science (RANDOM ’98). Springer- Verlag, Berlin, Heidelberg, 159–170

    1998

  75. [83]

    Kiet Tuan Pham, Seokjoo Cho, Sangjin Lee, Lan Anh Nguyen, Hyeongi Yeo, Ipoom Jeong, Sungjin Lee, Nam Sung Kim, and Yongseok Son. 2024. ScaleCache: A Scalable Page Cache for Multiple Solid-State Drives. InProceedings of the Nineteenth European Conference on Computer Systems(Ath...

    2024

  76. [84]

    Rajeev Raman and Satti Srinivasa Rao. 2003. Succinct dynamic dictionaries and trees. InProceedings of the 30th International Conference on Automata, Languages and Programming(Eindhoven, The Netherlands)(ICALP’03). Springer-Verlag, Berlin, Heidelberg, 357–368

    2003

  77. [85]

    Christian Rodriguez. [n. d.]. TinyPointers. https://github.com/rodrigch18/ TinyPointers. GitHub repository, accessed 2026-02-16

    2026

  78. [86]

    Ori Shalev and Nir Shavit. 2006. Split-ordered lists: Lock-free extensible hash tables.J. ACM53, 3 (May 2006), 379–405. https://doi.org/10.1145/1147954. 1147958

    2006 doi

  79. [87]

    Rajeev Raman and Satti Srinivasa Rao. 2003. Succinct dynamic dictionaries and trees. InInternational Colloquium on Automata, Languages, and Programming. Springer, 357–368

    2003

  80. [88]

    Kunal Talwar and Udi Wieder. 2013. Balanced Allocations: A Simple Proof for the Heavily Loaded Case.CoRRabs/1310.5367 (2013). arXiv:1310.5367 http://arxiv.org/abs/1310.5367

    2013 arXiv

  81. [89]

    Xilin Tang, Feng Zhang, Shuhao Zhang, Yani Liu, Bingsheng He, Bingsheng He, Xiaoyong Du, and Xiaoyong Du. 2024. Enabling Adaptive Sampling for Intra-Window Join: Simultaneously Optimizing Quantity and Quality.Proc. ACM Manag. Data2, 4, Article 198 (Sept. 2024), 31 pages. https...

    2024

  82. [90]

    The Linux Kernel Developers. 2025. Seqlock Implementation in the Linux Kernel. https://elixir.bootlin.com/linux/latest/source/include/linux/seqlock.h. Accessed: 2025-10-29

    2025

  83. [91]

    Alex C Snoeren, Craig Partridge, Luis A Sanchez, Christine E Jones, Fabrice Tchakountio, Stephen T Kent, and W Timothy Strayer. 2001. Hash-based IP traceback.ACM SIGCOMM Computer Communication Review31, 4 (2001), 3–14

    2001

  84. [92]

    Andrew Todd, Huan Truong, Justin Deters, John Long, Gavin Conant, and Michela Becchi. 2016. Parallel gene upstream comparison via multi-level hash tables on gpu. In2016 IEEE 22nd International Conference on Parallel and Dis- tributed Systems (ICPADS). IEEE, 1049–1058. Xilin Ta...

    2016

  85. [93]

    Lukas Vogel, Alexander van Renen, Satoshi Imamura, Jana Giceva, Thomas Neumann, and Alfons Kemper. 2022. Plush: a write-optimized persistent log- structured hash-table.Proc. VLDB Endow.15, 11 (July 2022), 2895–2907. https: //doi.org/10.14778/3551793.3551839

    2022

  86. [94]

    David Wajc. 2017. Negative Association-Definition , Properties , and Applica- tions. https://api.semanticscholar.org/CorpusID:30644334

    2017

  87. [95]

    The Linux Kernel Developers. 2025. Sequence Locks (seqlock). https://www. kernel.org/doc/Documentation/locking/seqlock.txt. Accessed: 2025-10-29

    2025

  88. [96]

    Junchang Wang, Dunwei Liu, Xiong Fu, Fu Xiao, and Chen Tian. 2022. DHASH: Dynamic Hash Tables With Non-Blocking Regular Operations.IEEE Trans- actions on Parallel and Distributed Systems33, 12 (Jan. 2022), 3274–3290. https://doi.org/10.1109/TPDS.2022.3151499

    2022

  89. [97]

    Tamer Özsu, and Walid G

    Ruihong Wang, Jianguo Wang, Stratos Idreos, M. Tamer Özsu, and Walid G. Aref. 2022. The case for distributed shared-memory databases with RDMA- enabled memory disaggregation.Proc. VLDB Endow.16, 1 (Sept. 2022), 15–22. https://doi.org/10.14778/3561261.3561263

    2022

  90. [98]

    Ziqi Wang. 2016. index-microbench. https://github.com/wangziqi2016/index- microbench Accessed: 2025-10-21

    2016

  91. [99]

    Chao Wang, Junliang Hu, Tsun-Yu Yang, Yuhong Liang, and Ming-Chang Yang

  92. [100]

    Shuotao Xu, Sungjin Lee, Sang-Woo Jun, Ming Liu, Jamey Hicks, and Arvind

  93. [101]

    Kai Zhang, Kaibo Wang, Yuan Yuan, Lei Guo, Rubao Lee, and Xiaodong Zhang

  94. [104]

    Derrick E Wood, Jennifer Lu, and Ben Langmead. 2019. Improved metagenomic analysis with Kraken 2.Genome biology20, 1 (2019), 257

    2019

  95. [1998]

    InProceedings of the thirtieth annual ACM symposium on Theory of computing

    Min-wise independent permutations. InProceedings of the thirtieth annual ACM symposium on Theory of computing. 327–336

  96. [2013]

    https://github.com/efficient/libcuckoo Accessed: 2025-10-21

    libcuckoo. https://github.com/efficient/libcuckoo Accessed: 2025-10-21

    2025

  97. [2015]

    VLDB Endow.8, 11 (July 2015), 1226–1237

    Mega-KV: a case for GPUs to maximize the throughput of in-memory key-value stores.Proc. VLDB Endow.8, 11 (July 2015), 1226–1237. https: //doi.org/10.14778/2809974.2809984

    2015

  98. [2016]

    VLDB Endow.10, 4 (Nov

    Bluecache: a scalable distributed flash-based key-value store.Proc. VLDB Endow.10, 4 (Nov. 2016), 301–312. https://doi.org/10.14778/3025111.3025113

    2016

  99. [2022]

    VLDB Endow.15, 10 (June 2022), 1978–1990

    VIP hashing: adapting to skew in popularity of data on the fly.Proc. VLDB Endow.15, 10 (June 2022), 1978–1990. https://doi.org/10.14778/3547305.3547306

    2022

  100. [2023]

    In17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23)

    SEPH: Scalable, Efficient, and Predictable Hashing on Persistent Memory. In17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23). USENIX Association, Boston, MA, 479–495. https://www.usenix. org/conference/osdi23/presentation/wang-chao

Pith tools

Reviewed August 3, 2026 · model on record in the stance chip above.