acceptodds
Under review as a conference paper at ICLR 2027

Attention via Black-Box Vector Search

Abstract

Sparse attention mechanisms estimate attention over tokens using a small subset of keys. Many existing approaches use maximum inner product search (MIPS) to retrieve the heaviest keys, which motivates the following question: given *black-box* access to a MIPS oracle, how many keys must be retrieved to output an -accurate attention estimate? We answer this question by unifying prior approaches through the framework of *priority sampling*. With a single MIPS index, we show that retrieved keys are both sufficient and necessary. With indices, we give an algorithm that retrieves only keys and prove that this is near-optimal. More generally, we design algorithms that establish a smooth tradeoff between the number of MIPS indices and number of retrieved keys. We then show that if we allow augmentation of keys and queries, we can bypass the above lower bounds: there exists a simple priority-sampling estimator using a single MIPS index and retrieved keys. When integrated into LLM inference, our algorithms outperform top- and sampling approaches used in prior work and yield attention approximation that scales favorably to long contexts.

Primary area:
optimization
Keywords:
attention, sparse attention, nearest neighbor search, maximum inner product search

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_MjvoOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies how many keys need to be retrieved to approximate softmax attention when maximum inner product search is a black-box operation. It develops a priority-sampling framework, gives algorithms and lower bounds for different index budgets, and proposes SoftmaxLift, which implements priority sampling through only a single MIPS index by adding one random coordinate. Experiments show attention approximation and downstream performance at 128K and 1M context lengths.

Critical strengths
  1. The paper answers a interesting question and builds a clear theoretical framework. Sampling + topk for attention is not new, as known as vAttention (ICLR 2026). What is interesting here is the systematic treatment of retrieval cost: the paper studies what can be achieved with different numbers of indices and provides lower bounds explaining the limitations.

  2. The idea makes sense, and SoftmaxLift is simple but practical. Only using the largest attention weights is not always enough to estimate the full weighted sum. Priority sampling addresses this naturally, and SoftmaxLift supports blackbox MIPS implementing priority sampling by adding one coordinate is a natural and useful method.

  3. The experiments show a clear estimation benefit. At 128K with exact retrieval and a budget of 128, SoftmaxLift reduces attention error from 0.3831 for TopK to 0.0794 and improves the RULER score from 40.56 to 60.22 (Table 2). The comparisons across budgets and search backends support the usefulness of the sampling strategy.

Critical weaknesses
  1. The experiment on Table 2 needs more explanation. IVF achieves higher recall than HNSW (0.966 vs. 0.926), yet has a lower RULER score (45.28 vs. 50.53). What explains this discrepancy? Moreover, their RULER scores fall approximately 15 and 10 percentage points below SoftmaxLift–Flat (60.22), respectively. What makes these retrieval errors so consequential for downstream quality? Figure 3 already explores larger retrieval budgets; could the authors explain how much increasing (k) recovers the lost quality, and why any remaining gap persists?

  2. Additional experiment with an existing sparse-attention method would be more helpful. Since your framework treats vector search as a black box, SoftmaxLift seems applicable to existing MIPS-based top-k attention methods, such as PQCache (SIGMOD 2025) or RetrievalAttention (NeurIPS 2025). I am curious whether these methods would benefit from your technique.

  3. Some minors in Appendix: In Claim 7, the variance bound at lines 717–718 is missing a square on the maximum value norm. In Lemma 12, the query is defined as (q_i=\tau\log p_i), but the proof subsequently states (\langle q,x_i\rangle=\log p_i) and uses (\exp(q_i)) to recover weights (p_i). The \tau is missing.

Questions for authors

Please check the weaknesses above.

3 comments

Thanks for the constructive and detailed review!

Mismatch between recall and benchmark score. The reviewer points out an interesting discrepancy between IVF and HNSW (with SoftmaxLift). IVF achieves better recall (0.966 vs 0.926), similar attention error, but worse RULER score (45.28 vs. 50.53). While we don’t have a definitive explanation for this particular result, we believe there are two relevant factors.

First, recall@k does not capture the relative importance of the retrieved keys. It treats all keys equally, whereas their contributions to the attention vector can vary substantially. Thus, a method with higher recall may still miss a small number of keys with large attention contributions and incur more attention error.

Second, average attention error does not fully determine downstream task completion. RULER consists of needle-in-a-haystack-like tasks where success is determined by retrieving a small number of tokens from a long context. It is possible that for these tasks, approximating the attention vector is less important than finding the value vectors corresponding to the important tokens. An important direction for future work is to evaluate our methods on a more diverse set of benchmarks to see if this discrepancy persists.

Increasing the retrieval budget. Increasing the retrieval budget k helps reduce the variance of the attention estimator. However, for most approximate oracles such as IVF and HNSW, increasing k alone only extends the list of retrieved keys and does not recover important keys that were missed at smaller retrieval budgets. Such errors can only be corrected by adjusting the parameters of the search oracle or choosing a different search oracle altogether.

Comparison with existing methods. We thank the reviewer for this suggestion. SoftmaxLift is directly applicable to both PQCache and RetrievalAttention. Both use TopK retrieval but differ in their choice of MIPS oracle: PQCache performs MIPS over product-quantized keys, and RetrievalAttention uses a graph index designed for out-of-distribution queries. Our work instead focuses on improving the retrieval strategy and estimator for a fixed oracle, which is why we evaluated a relatively small set of standard oracles. Combining SoftmaxLift with the search oracles of PQCache and RetrievalAttention (and developing more optimized oracles in general) is a reasonable avenue for further experimentation, and we leave it for future work.

Typographical fixes. We thank the reviewer for pointing out these typos. They have been fixed in the updated version of the paper.

If IVF and HNSW miss keys in roughly the same way, I’d expect higher recall to generally bring SoftmaxLift closer to the exact-search result(highest among the SoftmaxLift variants in Table 2). IVF may have happened to miss a few keys needed to answer questions that HNSW got right. It’s also possible that IVF’s partitioning makes it systematically more likely to miss certain keys. This rebuttal only gives me a plausible explanation for why recall and RULER score can diverge. I would have liked to see a few more runs or an analysis of individual failures to tell which explanation fits this result. I understand that testing SoftmaxLift with PQCache or RetrievalAttention would take more work. For me, the problem about recall and RULER mismatch in the existing experiment is the more important to answer.

Thank you for following up -- we agree that this is an interesting question to dig into. We ran some additional experiments to address why IVF has higher recall yet HNSW has similar attention error and better benchmark scores. We address this in two parts: (1) why HNSW gets better benchmark scores than IVF even though the attention errors are roughly the same, and (2) why HNSW gets similar attention error to IVF even though IVF has much better recall.

(1) Attention error vs. benchmark score. When we look at attention errors and benchmark scores task-by-task rather than aggregated across tasks, we see that attention error and benchmark score are actually well-aligned. Aggregating creates a “gerrymandering”-style effect: the tasks where HNSW loses to IVF substantially increase the attention error of HNSW but only slightly increase the average benchmark score.

For more detail, here is a table showing benchmark scores, attention accuracies, and recall for SoftmaxLift with HNSW and with IVF run on 130 document examples (13 from each task, the 60 from the paper and 70 more we have added since).

TaskIVF attention error ↓HNSW attention error ↓IVF RULER (%) ↑HNSW RULER (%) ↑IVF recall ↑HNSW recall ↑
niah_single_10.11290.188092.3130.770.96850.9429
niah_single_20.13800.110684.62100.000.96660.9159
niah_multikey_10.13610.110869.23100.000.96530.9150
niah_multikey_20.09710.116453.8546.150.97410.9354
niah_multivalue0.14090.105625.0032.690.96360.9142
niah_multiquery0.13540.104726.9253.850.96370.9114
vt0.10400.119333.8553.850.96080.9474
fwe0.08550.117856.4161.540.97200.9431
qa_10.11870.115423.0846.150.96680.9167
qa_20.12770.116623.0823.080.96460.9118
Overall0.12050.119748.8354.810.96620.9263

(IVF uses 1,024 clusters and nprobe=96. HNSW uses M=48, efConstruction=500, efSearch=176)

There are 4 tasks where HNSW incurs larger attention error than IVF. These contain the only 2 tasks where HNSW has a lower benchmark score (niah_single_1, niah_multikey_2). In the other 2 tasks (vt, fwe), HNSW has a higher benchmark score, but either the attention errors or benchmark scores are close to tied. Interestingly, these 4 tasks are exactly those where a common set of words is repeated many times (e.g., in niah_single_1, the key words are inserted inside a repeating small phrase). It’s possible that this generates key vectors with many near-duplicates of the same point (up to positional embeddings). We did not look further at how exactly this geometry affects the different oracles, but perhaps graph-based oracles like HNSW struggle with such duplicates. The other 6 tested tasks have a much more diverse set of words with few repetitions.

(2) Recall vs. attention error. For this part of the question, we confirmed that even though IVF consistently misses less points in the top-k than HNSW, the missed points for IVF carry more attention weight. The following table contains the average attention mass of the keys in the true top-k that are missed by the approximate oracle:

OracleRecall@128 ↑Average attention weight of a missed keyTotal missed attention mass, averaged per query
IVF96.46%0.0020840.009438
HNSW92.36%0.0008330.008141

Results are averaged over 41,244 queries from a sample of 192 heads in our 128k-context experiments.

The average key missed by IVF has about 2.5x the attention weight of the average key missed by HNSW. Notably, IVF misses less than half as many keys as HNSW, but it misses more attention weight in total. Restricting to the 6 tasks where HNSW has better attention error, the effect is even stronger: the average key missed by IVF has about 3.2x the attention weight of the average key missed by HNSW.

So, it seems that HNSW misses more keys than IVF, but the keys missed by HNSW are in the top-k due their large lift components (i.e., their final coordinate in the SoftmaxLift transform) rather than having large attention mass. We do not have a concrete explanation for this phenomenon. But, one hypothesis is that IVF’s spherical k-means clustering concentrates keys with large lift components into clusters whose centroids score highly against many queries, using up probes that could otherwise reach some keys with high attention weight. HNSW’s graph search might be less susceptible to this effect. Testing this would require further experimentation.

These results suggest that although SoftmaxLift outperforms other retrieval strategies, its transformation of the key vectors may introduce systematic biases in approximate MIPS oracles. Designing retrieval strategies that reduce these biases could be an interesting direction for future work.

Reviewer_cz8EOpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper studies sparse attention in a model where, at query time, the n keys can be accessed only through T black-box maximum inner product search (MIPS) indices, built on subsets of keys of the algorithm’s choice, and through direct inner product evaluations. It asks how many keys must be retrieved for an ε-accurate estimate of attention. For kernel density estimation, earlier work gives O(√n/ε) keys with one index and O(log n/ε²) keys with O(log n) indices. The paper’s main result is an adaptive algorithm that uses T indices and retrieves O(T + n^{1/(T+1)} ε^{−2+2/(T+1)}) keys, which for T = Θ(log n) improves the earlier O(log n/ε²) to O(log n + 1/ε²), and a non-adaptive variant that retrieves a factor T more. Both algorithms use priority sampling (Duffield, Lund and Thorup 2007). The authors also complement these with lower bounds of Ω(√n/ε) keys for one index and Ω(log n/log log n + 1/ε²) for any number of indices, so the one-index bound is optimal. Finally, the authors give an algorithm, SoftmaxLift, that appends the negative logarithm of each key’s random scale as an extra coordinate, so that the algorithm finds the priority sample with one MIPS query, and retrieves O(1/ε²) keys with a single index. In experiments for 128K context, SoftmaxLift has lower attention error than top-k retrieval (0.08 vs. 0.38 for k = 128).

Critical strengths

This paper nicely blends theoretical results with a realistic practical angle.

  • An upper bound for every number of indices. Earlier work covered two cases: O(√n/ε) keys with one index and O(log n/ε²) keys with O(log n) indices. Theorem 1 gives a bound for every number of indices T, retrieving O(T + n^{1/(T+1)} ε^{−2+2/(T+1)}) keys. It matches the first case for T = 1 and improves the second to O(log n + 1/ε²) for T = Θ(log n).

  • Lower bounds for the MIPS model. Earlier work in this model gave no lower bounds. With one index, Theorem 3 shows that Ω(√n/ε) retrieved keys are necessary whichever keys the algorithm indexes, so the one-index bound is optimal. With any number of indices, Theorem 4 shows that Ω(log n/log log n + 1/ε²) keys are necessary, which Theorem 1 nearly matches for T = Θ(log n).

Critical weaknesses

The paper claims that SoftmaxLift is useful for long contexts, but it tests only two context lengths, 128K and 1M, with a different model and different settings for each. For 1M context, on 8 examples, SoftmaxLift is faster than exact attention only with the approximate IVF oracle, and then it scores 58.3 on RULER, against 85.4 for exact attention. With exact search it scores 83.3 but is slower than exact attention.

Questions for authors
  • The tradeoff is tight only for T = 1 and, up to a log log n factor, for T = Θ(log n). For T = 2 the upper bound is n^{1/3}ε^{−4/3}, while the lower bound is log n/log log n + 1/ε². Is the n^{1/(T+1)} factor necessary for constant T ≥ 2?

  • No lower bound separates adaptive from non-adaptive algorithms. Is the factor-T loss in Theorem 2 necessary? For example, must a non-adaptive algorithm with Θ(log n) indices retrieve Ω(log n/ε²) keys?

  • Since one extra coordinate per key removes the lower bounds (Theorem 5), why is restricting the indices to the original keys a reasonable assumption for attention?

2 comments

Thanks for the constructive and detailed review!

Limited practical benefits. We acknowledge that the 1M context experiments in our submission are not very compelling: SoftmaxLift with an approximate oracle achieves much worse RULER score than exact attention (58.3 versus 85.4), while with an exact oracle it is slower than exact attention. After a follow-up experiment, we believe this was a result of suboptimal parameter settings. In the paper, we used an IVF oracle with 1024 total clusters and 64 probed clusters for our 1M context experiments; by instead using 128 probed clusters (i.e., nprobe=128), Softmax Lift achieves 2.34× faster token generation than exact GPU, with only 0.0478 relative L2 attention error and a 1.24 percentage-point loss in benchmark score; see the table below. We have added these results in the updated version of the paper. Furthermore, the experiment averages over 70 examples across 10 tasks, with seven examples per task (as opposed to the original 8 examples across 4 tasks in the paper).

We include results of the 70 example experiment in the table below. IVF oracles use nlist=1024.

Retrieval strategyOracleAttention error (rel. L2) ↓RULER score (%) ↑Later-token latency (s/token) ↓
Softmax LiftFlat0.018555.212.536
Softmax LiftIVF (nprobe=128)0.047854.570.780
Softmax LiftIVF (nprobe=64)0.071745.640.519
Top-k+samplingFlat0.189754.812.835
Top-k+samplingIVF (nprobe=128)0.269342.641.541
Top-k+samplingIVF (nprobe=64)0.310923.450.980
Exact GPU—055.811.819

We would like to make two remarks on this table. First, note that the exact gpu benchmark scores in this table are lower than the old 1M experiments. This is because we are including more tasks, some of which are more challenging for the model. Second, note that both retrieval strategies with a flat oracle perform just as well as exact attention, but the attention error of Softmax Lift is significantly smaller. When we introduce oracle errors, though, the benchmark scores of Softmax Lift are higher than those of TopK+Sampling. This shows that attention error is not a perfect predictor of benchmark score, and the relationship between the two is an interesting direction for future study.

In the final version of the paper, we will also include TopK results. For timing accuracy, we are running all experiments on a single machine, which takes about 2 hours/example on such large contexts. We do not yet have TopK runs for all 70 examples, but preliminary evidence points to TopK being worse in accuracy but slightly faster than TopK+Sampling.

Necessity of the n1/(T+1)n^{1/(T+1)} factor. The reviewer points out the large gap between our upper and lower bounds on retrieval cost when T is a constant larger than 1. We strongly believe that the tradeoffs established in our upper bounds are tight, though we do not have a formal proof; we have an LLM-generated proof (via gpt-6-astra) showing that n1/(T+1)n^{1/(T+1)} retrieved keys are necessary, but we have not fully verified it.

Non-adaptive lower bound. We acknowledge the reviewer’s point that we do not currently have a lower bound separating adaptive from non-adaptive algorithms. We believe the factor-T loss in Theorem 2 is necessary, but we do not yet have a formal proof for this.

Restricting to the original keys. In our view, restricting indices to the original keys is reasonable because it captures existing methods for MIPS-based sparse attention. Popular methods use Top-k retrieval (as in RetrievalAttention) and Top-k + Sampling (as in vAttention) over the original keys. Theorems 3 and 4 show the limitation of approaches that build indices over the original keys: strong lower bounds. One message of this work is that the implicit restriction to original keys might be holding existing methods back. Indeed, Theorem 5 demonstrates that asymptotically better tradeoffs are possible once the restriction is lifted, and our experimental results corroborate this. A broader model allowing transformations to the keys would be interesting, but it would also require careful definition because the resulting MIPS instance may encode a problem as hard as computing attention (thereby trivializing the problem).

Thank you for the informative rebuttal. I will keep my score.

Reviewer_v1DDOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies how to approximate softmax attention using black-box maximum inner product search (MIPS). It assigns each key an independent uniform random number uiu_i and defines its sampling priority as its unnormalized attention weight divided by uiu_i. The highest-priority keys are selected and reweighted to estimate full attention. The paper establishes tradeoffs between index count and retrieval cost, together with lower bounds. It also proposes SoftmaxLift, which appends a random coordinate to each key to retrieve these priorities through a single MIPS index, and evaluates the method on long-context LLM inference.

Critical strengths
  1. The theoretical analysis goes beyond upper bounds: a matching lower bound establishes optimal retrieval complexity in the single-index setting, clarifying the limitations of the specified MIPS access model.

  2. SoftmaxLift is simple and achieves substantially better attention approximation quality than top-k and top-k plus uniform sampling at matched retrieval budgets.

Critical weaknesses
  1. Limited practical benefits. At 128K context, the proposed methods remain slower than exact GPU attention. At 1M, the approximately 3× decoding speedup comes with a substantial RULER score decrease, from 85.42 to 58.33, and is evaluated on only eight examples.

  2. Insufficient baseline comparisons. The experiments mainly compare against top-k and top-k plus uniform sampling. Comparisons with competitive sparse-attention methods and, where applicable, linear-attention approaches are missing, leaving competitiveness with existing efficient-attention methods unclear.

  3. **The novelty of SoftmaxLift and the bucketing scheme is unclear." SoftmaxLift is essentially Mussmann & Ermon (2016)'s construction. That work appends frozen perturbation noise as an extra coordinate of the database vectors and stores it in the MIPS index. Mussmann et al. (2017) describe it in exactly those terms: "Gumbel noise is appended to the database vectors and stored in the MIPS data structure". The present paper replaces Gumbel-max sampling with priority sampling and HT reweighting. This substitution is closely related to bottom-k / PPSWOR sketches with exponential ranks (Cohen & Kaplan), which also support threshold-based unbiased estimators.

Questions for authors
  1. The experiments evaluate 128K and 1M contexts, but do not report intermediate context lengths. Could the authors evaluate additional lengths, such as 256K and 512K, to clarify when the method begins to outperform exact attention in latency and whether comparable task accuracy can be maintained?
  2. How does it compare with existing sparse-attention systems, under matched hardware and accuracy targets?
  3. How exactly does SoftmaxLift relate to the frozen-Gumbel augmentation of Mussmann & Ermon (2016)? Can you state precisely why frozen noise is acceptable here, given the correlation criticism in Mussmann et al. (2017)?
2 comments

Thanks for the constructive and detailed review!

Limited practical benefits. The reviewer notes that at 128k context, our approximate attention method is slower than exact attention, while at 1M context, our approximate methods achieve worse benchmark performance. We fully accept the reviewer’s point - but after a follow-up experiment, we believe that this was a result of suboptimal parameter settings. In the paper, we used an IVF oracle with 1024 total clusters and 64 probed clusters for our 1M context experiments; by instead using 128 probed clusters (i.e., nprobe=128), Softmax Lift achieves 2.34× faster token generation than exact GPU, with only 0.0478 relative L2 attention error and a 1.24 percentage-point loss in benchmark score; see the table below. We have added these results in the updated version of the paper. Furthermore, the experiment averages over 70 examples across 10 tasks, with seven examples per task (as opposed to the original 8 examples across 4 tasks in the paper).

We include results of the 70 example experiment in the table below. IVF oracles use nlist=1024.

Retrieval strategyOracleAttention error (rel. L2) ↓RULER score (%) ↑Later-token latency (s/token) ↓
Softmax LiftFlat0.018555.212.536
Softmax LiftIVF (nprobe=128)0.047854.570.780
Softmax LiftIVF (nprobe=64)0.071745.640.519
Top-k+samplingFlat0.189754.812.835
Top-k+samplingIVF (nprobe=128)0.269342.641.541
Top-k+samplingIVF (nprobe=64)0.310923.450.980
Exact GPU—055.811.819

We would like to make two remarks on this table. First, note that the exact GPU benchmark scores in this table are lower than the old 1M experiments. This is because we are including more tasks, some of which are more challenging for the model. Second, note that both retrieval strategies with a flat oracle perform just as well as exact attention, but the attention error of Softmax Lift is significantly smaller. When we introduce oracle errors, though, the benchmark scores of Softmax Lift are higher than those of TopK+Sampling. This shows that attention error is not a perfect predictor of benchmark score, and the relationship between the two is an interesting direction for future study.

In the final version of the paper, we will also include TopK results. For timing accuracy, we are running all experiments on a single machine, which takes about 2 hours/example on such large contexts. We do not yet have TopK runs for all 70 examples, but preliminary evidence points to TopK being worse in accuracy but slightly faster than TopK+Sampling.

Performance at 256k and 512k. We believe that, given the new 1M results, evaluating our approach at 256k and 512k context length would not add much to the paper. We expect to see the biggest gain at longer context lengths due to the empirically observed sublinear-time scaling of MIPS data structures.

Insufficient baselines. The goal of our paper was to answer a narrow but important question: how to use vector search algorithms to obtain provable and fast attention approximation. We provide a strong theoretical answer to this question and give evidence that our algorithms may be useful in practice. Optimizing our approach for certain hardware and comparing to other sparse attention systems is an interesting direction for future work but is out of scope for this paper.

Unclear novelty. We take the reviewer’s point about the Gumbel noise augmentation of Mussmann & Ermon (2016). While their estimator would not give similar parameters (dimension increases by k, and we need k queries), there is a version of the Gumbel trick (Gumbel-top-k) that can be used to obtain a similar theoretical guarantee as SoftmaxLift, and we will make this clear in our paper. The main novelty of our work is our priority sampling framework for attention, its analysis, and the tradeoffs between the number of indices and retrieval cost.

Frozen noise. We note that Mussmann et al. (2017)’s correlation criticism is not directly relevant here: in the original paper, the task was sampling and i.i.d. samples are essentially a requirement. In contrast, in our paper, randomization is used internally in the algorithm for a per-query error guarantee. For a stream of queries, the error guarantee follows immediately by taking a union bound. The only subtlety is: in autoregressive decoding, the keys/values may also depend on the noise and hence correlate with later queries. Extending our guarantee to adaptively chosen queries is an interesting future direction; in practice, one can correct the resulting errors with speculative decoding.

Dear Reviewer v1DD,

Thank you again for your detailed feedback. Please let us know whether our rebuttal and additional experiments address your concerns. We would be happy to clarify any remaining questions.

Best,

Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of changes to paper pdf

We have updated the paper pdf as part of our rebuttal. We made only two types of changes:

  • Expanded 1M-context experiments. We updated Table 3 and the accompanying discussion to include more extensive 1M-context experiments conducted after the original deadline. The table reports average attention error, RULER score, and token latency for 70 examples across 10 tasks (up from the original 8 examples across 4 tasks). We also added a parameter setting for the IVF oracle that, when combined with SoftmaxLift, compares very favorably with the exact GPU baseline. These results directly address concerns raised by Reviewers v1DD and cz8E about the practical benefits of our approach. Please see our individual rebuttal responses for further details.
  • Minor typographical corrections. We corrected the typographical errors in Appendices A and B identified by Reviewer Mjvo.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.