[0.9, 0.8] places a record at "roof concern 0.9, wind exposure 0.8". Each number is one dimension.The previous page ended at a wall. WHERE roof_type = 'metal' finds metal roofs exactly and cannot say which records look like "an older roof in a high-wind zone". BM25 finds rare words and ranks the roof-conflict rule R-ROOF-03 fourth for a paraphrase that shares only "roof" with it. Both tools compare symbols. The underwriter's question compares resemblance.
Picture how an experienced underwriter sorts paper files before any software. She lays them on a table, older-roof files to the right, high-wind files toward the top. A new file for SUB-1004, an older roof in wind zone C, goes near the top right. The files that resemble it are the ones lying close to it. Nobody wrote a rule called "similar"; position on the table did the work.
That table is the whole idea of this page. If each record gets a position, expressed as numbers, then "similar" becomes "close", and "close" is arithmetic. This page builds the arithmetic with no model at all: five records on a two-axis table, then three rows computed by hand, three ways. Only after the reader can rank three rows with a pencil does the next page bring in models that produce the numbers.
What this is not. This page does not explain how a model turns text into numbers; that is embeddings. It also does not cover indexes that skip rows to answer faster; those are on approximate nearest neighbors. Every vector here is written by hand or by a deterministic toy function.
A row becomes a point#
A vector is a list of numbers that places a row in space. The list [0.9, 0.8] is a point 0.9 along the first axis and 0.8 along the second. Each position in the list is a dimension, and the number of positions is the vector's dimension: [0.9, 0.8] has dimension 2.
The lab on this page uses five synthetic property records with two hand-picked dimensions: x is roof concern, y is wind exposure. The values come from vecmath.FIVE_ROWS in the example code.
| Row | Label | roof_type | wind_zone | Vector (x roof concern, y wind exposure) |
|---|---|---|---|---|
| 1 | older roof, wind zone C | asphalt | C | [0.9, 0.8] |
| 2 | new roof, wind zone C | metal | C | [0.2, 0.9] |
| 3 | older roof, wind zone A | asphalt | A | [0.8, 0.1] |
| 4 | new roof, wind zone A | metal | A | [0.1, 0.2] |
| 5 | roof age unknown, wind zone B | tile | B | [0.5, 0.5] |
The query, "an older roof in a high-wind zone", is a point too: [0.85, 0.7]. It is not stored in the table. It is computed at query time and compared with the rows.
Before AI. A backend engineer already runs this query in another form. "Find the five stores nearest to this customer" stores a latitude and longitude per store, computes a distance from the customer's point to each store, sorts, and keeps five. The coordinates are a two-dimensional vector per row; the customer's position is the query vector. Vector retrieval is that query with more dimensions and coordinates that stand for meaning instead of geography.
Distance: how far apart two points are#
The most familiar distance is the straight line between two points. For two vectors a and b it is the square root of the sum of squared differences, dimension by dimension. It is called Euclidean distance, or L2 distance. Smaller means closer.
Compute it for the query [0.85, 0.7] and row 1 [0.9, 0.8]:
- Differences: 0.9 − 0.85 = 0.05, and 0.8 − 0.7 = 0.1.
- Squares: 0.0025 and 0.01.
- Sum: 0.0125. Square root: 0.1118.
Row 4, [0.1, 0.2], gives differences 0.75 and 0.5, squares 0.5625 and 0.25, sum 0.8125 and distance 0.9014. Row 1 is the close one, which matches intuition: it is the older roof in wind zone C.
The critical idea: one vector per row, compared row by row#
Here is the sentence this whole site keeps true, now with numbers behind it. An embedding column holds one vector per row. A vector query compares the query vector with each row's vector, ranks the rows by distance and returns the nearest k. The model reads only what retrieval returned. Retrieval is a query. The model reads only what it returns.
Read the table above as a database table: the last column is the embedding column. Row 1 has its vector, row 2 has its own, and so on. There is no single vector "for the table". When the query arrives, the database computes five distances, one per row, sorts the five rows by them, and returns the first k. With k = 2 it returns rows 1 and 5.
The rows it returns are called the nearest neighbors of the query: the stored rows whose vectors are closest to the query vector. Keeping the first k of them is top-k. In SQL the whole operation is one familiar shape, ORDER BY distance LIMIT k; the exact search page writes it against PostgreSQL with bound parameters.
Diagram: One vector per row: the query is compared with every row, then the rows are sorted
Read left to right. The query vector is computed at query time. Each of the five rows has its own stored vector, and each comparison yields one distance. The sort runs over rows, and LIMIT keeps the nearest k. There is no vector for the table as a whole. Click a box for its numbers.
- Query time
- Query vector: The question as a point: an older roof in a high-wind zone; not stored in the table.
- Embedding column: one vector per row
- Row 1: Older roof, wind zone C: distance 0.1118 from the query.
- Row 5: Roof age unknown, wind zone B: distance 0.4031.
- Rows 3, 2, 4: The other three rows, each compared the same way, one distance each.
- Rank the rows
- Sort by distance: Rows are ordered by their own distance to the query, smallest first.
- Keep the nearest k: The first k rows are the nearest neighbors; only they reach the model.
The diagram is the picture to keep. The query vector fans out to every row, each comparison produces one number, and the sort happens over rows. Adding a sixth row adds one more comparison and changes nothing about the five vectors already stored. That is why growing a table does not require recomputing the vectors already in it, a point the scale page measures.
Common confusion. "We embedded the table." A table is not embedded; each row's text is embedded into that row's vector. Two consequences follow. A new row needs one new vector, not a rebuild of the others. And the query never sees "the table's meaning"; it sees one distance per candidate row.
The lab: five rows, one query, every row compared#
Drag or nudge the query point in the lab. The distances to all five rows, the ORDER BY ... LIMIT k result and the SQL update as you move. The WHERE toggle applies an exact filter first (wind_zone = 'C' or roof_type = 'asphalt'), to contrast keeping exact values with ranking by distance, and a metric choice switches between L2 (<->) and cosine (<=>). The data is synthetic and the vectors are written by hand.
The same result without JavaScript, from the run of rows_by_hand.py below (query [0.85, 0.7], rows sorted by L2 distance):
| Rank by L2 | Row | Vector | L2 distance | Cosine distance | Label |
|---|---|---|---|---|---|
| 1 | 1 | [0.9, 0.8] | 0.1118 | 0.0007 | older roof, wind zone C |
| 2 | 5 | [0.5, 0.5] | 0.4031 | 0.0046 | roof age unknown, wind zone B |
| 3 | 3 | [0.8, 0.1] | 0.6021 | 0.1552 | older roof, wind zone A |
| 4 | 2 | [0.2, 0.9] | 0.6801 | 0.2120 | new roof, wind zone C |
| 5 | 4 | [0.1, 0.2] | 0.9014 | 0.0862 | new roof, wind zone A |
With the filter WHERE roof_type = 'metal', only rows 2 and 4 remain, and they are the two rows farthest from the query. The filter answered its own exact question correctly; it was the wrong question.
Running it: the same five rows in Python#
The script below is a short file added to a scratch copy of examples/rag-uw; it calls only vecmath.py. It demonstrates the primitive: one vector per row, one distance per row, a sort over rows, and the first k. A successful run proves the hand arithmetic above and shows that the exact filter and the ranking answer different questions. It does not show anything about real embeddings, whose coordinates no person picks.
# rows_by_hand.py, run from a scratch copy of examples/rag-uw
from vecmath import FIVE_ROWS, FIVE_ROWS_QUERY, cosine_distance, l2
q = FIVE_ROWS_QUERY
print("query vector:", q)
print("WHERE roof_type = 'metal' ->", [r["id"] for r in FIVE_ROWS if r["roof_type"] == "metal"])
scored = sorted((l2(q, r["vec"]), r["id"]) for r in FIVE_ROWS)
for dist, rid in scored:
row = next(r for r in FIVE_ROWS if r["id"] == rid)
print(f" row {rid} {row['vec']} L2 = {dist:.4f} cosine distance = {cosine_distance(q, row['vec']):.4f} {row['label']}")
print("ORDER BY L2 LIMIT 2 ->", [rid for _, rid in scored[:2]])
query vector: [0.85, 0.7]
WHERE roof_type = 'metal' -> [2, 4]
row 1 [0.9, 0.8] L2 = 0.1118 cosine distance = 0.0007 older roof, wind zone C
row 5 [0.5, 0.5] L2 = 0.4031 cosine distance = 0.0046 roof age unknown, wind zone B
row 3 [0.8, 0.1] L2 = 0.6021 cosine distance = 0.1552 older roof, wind zone A
row 2 [0.2, 0.9] L2 = 0.6801 cosine distance = 0.2120 new roof, wind zone C
row 4 [0.1, 0.2] L2 = 0.9014 cosine distance = 0.0862 new roof, wind zone A
ORDER BY L2 LIMIT 2 -> [1, 5]
One column deserves a second look. By L2, row 4 is the farthest row. By cosine distance, it is third, ahead of rows 3 and 2. Row 4 [0.1, 0.2] is a short vector pointing in almost the same direction as the query; it is far away and nearly aligned. Two reasonable definitions of "close" disagree, and the next section shows exactly why.
Three rows by hand: dot product, distance and cosine#
To see the disagreement clearly, the example uses three rows with small integers so that every step fits on paper. The dimensions are named [roof, age, conflict], as if each number measured how much a passage talks about each concept. The query is q = [1, 2, 2], a question mostly about age and conflict. The rows come from vecmath.THREE_ROWS.
| Row | Label | Vector [roof, age, conflict] |
|---|---|---|
| r1 | roof rule | [2, 1, 2] |
| r2 | age-conflict rule | [0, 3, 4] |
| r3 | roof-only note | [4, 0, 0] |
Dot product. Multiply the two vectors position by position and add. It grows when both vectors are large in the same dimensions. For q and r1: 1×2 + 2×1 + 2×2 = 8. For r2: 0 + 6 + 8 = 14. For r3: 4 + 0 + 0 = 4. Larger means more aligned, so the dot product ranks r2, r1, r3.
Euclidean distance. For q and r1: differences 1, −1, 0; squares 1, 1, 0; sum 2; distance √2 = 1.414. For r2: differences −1, 1, 2; squares 1, 1, 4; sum 6; distance 2.449. For r3: differences 3, −2, −2; sum 17; distance 4.123. Smaller means closer, so L2 ranks r1, r2, r3.
Cosine similarity. Divide the dot product by the product of the two lengths. A vector's length is the square root of its dot product with itself: |q| = √9 = 3, |r1| = 3, |r2| = 5, |r3| = 4. Cosine for r1 is 8 / (3 × 3) = 0.8889; for r2, 14 / (3 × 5) = 0.9333; for r3, 4 / (3 × 4) = 0.3333. Cosine measures the angle between two vectors and ignores their lengths; larger means closer, from 1 for the same direction down to −1 for opposite directions. It ranks r2, r1, r3.
Cosine distance. Many databases sort ascending, so they use cosine distance, defined as 1 minus cosine similarity: 0.1111 for r1, 0.0667 for r2, 0.6667 for r3. Smaller means closer. Same ranking as cosine similarity, flipped scale.
| Row | Dot product | Length | L2 distance | Cosine similarity | Cosine distance |
|---|---|---|---|---|---|
| r1 roof rule | 8 | 3.000 | 1.414 (closest) | 0.8889 | 0.1111 |
| r2 age-conflict rule | 14 (largest) | 5.000 | 2.449 | 0.9333 (closest) | 0.0667 (closest) |
| r3 roof-only note | 4 | 4.000 | 4.123 | 0.3333 | 0.6667 |
L2 says r1 is nearest. Dot product and cosine say r2. Neither is a bug. r2 is a longer vector, length 5 against 3, so it is farther from q as a point, while pointing in nearly the same direction. L2 counts the length difference as distance; cosine ignores it. Dot product rewards it: part of r2's 14 comes from r2 being long.
Why they disagree, and how normalization makes them agree#
The disagreement comes entirely from length. So remove length. Normalization scales each vector to length 1 by dividing every coordinate by the vector's length: q becomes [1/3, 2/3, 2/3], r2 becomes [0, 0.6, 0.8]. A normalized vector keeps its direction and loses its size.
After normalization three things become true at once. The dot product of two unit vectors equals their cosine similarity, because the lengths in the cosine formula are both 1. The Euclidean distance between them is tied to cosine by a fixed rule: L2 squared equals 2 minus 2 times the cosine. And so all three metrics rank the rows in the same order. Check r1: 2 − 2 × 0.8889 = 0.2222, whose square root is 0.4714.
vecmath.py prints every number of this table, before and after normalization. A successful run proves the arithmetic above and the agreement after normalization; it proves nothing about which metric suits a given embedding model, which is that model's documentation's job.
cd /tmp/rag-uw && /opt/homebrew/bin/python3 vecmath.py
query [1, 2, 2] |q| = 3.000
r1: dot=8 |v|=3.000 L2=1.414 cos=0.8889 cos_dist=0.1111 dot(normalized)=0.8889 L2(normalized)=0.4714
r2: dot=14 |v|=5.000 L2=2.449 cos=0.9333 cos_dist=0.0667 dot(normalized)=0.9333 L2(normalized)=0.3651
r3: dot=4 |v|=4.000 L2=4.123 cos=0.3333 cos_dist=0.6667 dot(normalized)=0.3333 L2(normalized)=1.1547
mulberry32(42) first five u32: [2581720956, 1925393290, 3661312704, 2876485805, 750819978]
The last two columns now agree with cosine: r2 first (0.9333 by dot, 0.3651 by L2), then r1, then r3. The final line is the example's seeded random generator, which the browser labs use to reproduce the same numbers; it is not part of the math.
The math lab steps through the same three rows. Its normalize toggle shows the dot product becoming equal to cosine. Without JavaScript, the table above and the vecmath.py output carry the same numbers.
Diagram: Three ways to measure closeness disagree on long and short vectors, and agree after normalization
Read left to right. On raw vectors, the dot product rewards length, L2 counts length as distance, and cosine ignores it, so the three rank the three rows differently. Normalization scales every vector to length 1, and then all three give the same order. Click a box for the hand computation.
- Raw vectors
- Dot product: Sum of position-by-position products; long vectors score higher.
- Euclidean distance: Straight-line distance between points; a longer vector is farther away.
- Cosine similarity: Dot product divided by both lengths; ignores length.
- One step
- Normalize: Every vector is scaled to length 1; direction stays, size goes.
- Unit vectors
- Same ranking: Dot product equals cosine, and L2 squared equals 2 minus 2 times cosine.
The diagram condenses the section. Three metrics read the same pair of vectors differently while lengths vary; one step, normalization, makes them interchangeable for ranking. That is why many retrieval systems normalize every vector once, at write time, and then use whichever operator their database runs fastest.
In the insurance build. In that build, vectors are L2-normalized in code and compared with cosine distance through<=>andvector_cosine_ops, so cosine and inner product rank rows identically.
In Mnemos. In the code read, Mnemos sets nodistance_metricon itsvec0table, so it uses the documented default, L2; the vectors are normalized at embedding time, so L2 and cosine rank the same even though the code comments call the distance "cosine".
Where the numbers come from in the insurance example#
In the five-row lab a person chose the coordinates. In the insurance example a function produces them from text. The example code uses toy encoders: deterministic functions that map words to 16 named concept dimensions (roof, old, new, conflict, sprinkler, wind and ten more), add up the words of a text, and normalize the sum. They behave like an embedding model in the ways this site teaches, and they are not models. Toy encoders and synthetic data show how the mechanism works, not how good any model or product is. Real embedding models produce 384, 768 or more dimensions, and nobody can name what each one means.
The arithmetic does not change with the dimension. Here is this site's own case UW-R01 on the throwaway PostgreSQL database: every guidance passage has its own 16-dimensional vector, the query "roof replaced recently but aerial imagery shows an older roof" has one too, and <=> computes one cosine distance per row. The query is Q1 in examples/rag-uw/sql/queries.sql; the output is from sql/OUTPUT.md (PostgreSQL 16.14, pgvector 0.8.3, one run on one laptop, toy data; not a benchmark).
== Q1 exact cosine top-k over guidance, bound parameters (UW-R01)
PREPARE
passage_id | policy_version | status | cosine_distance
---------------------+----------------+------------+-----------------
GD-NOTE-01 | 2026.2 | current | 0.2293
GD-2025.4-R-ROOF-03 | 2025.4 | superseded | 0.3035
GD-2026.2-R-ROOF-03 | 2026.2 | current | 0.3035
GD-2025.4-R-ROOF-02 | 2025.4 | superseded | 0.3792
GD-2026.2-R-ROOF-02 | 2026.2 | current | 0.3792
The roof-conflict rule R-ROOF-03 is now near the top for a query that shares almost none of its words, which is what the SQL ladder could not do. The output also shows two passages tied at 0.3035: the superseded 2025.4 copy and the current 2026.2 copy of the same rule. Their texts differ only in the version number, and the toy encoder does not see numbers, so both rows got the same vector. Distance cannot tell versions apart; an exact filter on policy_version or status can. That is this site's case UW-R03, handled on exact search.
Failure modes: wrong direction, wrong metric, wrong length#
Most vector bugs are not exotic. They are the arithmetic above applied with one assumption wrong.
Sorting a similarity as if it were a distance. Cosine similarity is larger-is-closer; cosine distance is smaller-is-closer. Sort the similarity ascending and the query returns the least similar rows first, fluently and without error. Name every column ..._distance or ..._similarity, never score, and assert the direction in a test with a pair whose answer you know.
Ranking unnormalized vectors by dot product. In the three-row table, r2 wins the dot product partly because it is long. If stored vectors have different lengths for reasons unrelated to meaning, such as text length in some pipelines, the dot product rewards that. Normalize at write time, or use cosine.
Comparing vectors of different dimensions. A 16-number vector and a 384-number vector cannot be compared at all; vecmath.dot raises dimension mismatch, and a database column of a fixed dimension rejects the insert. That error is the easy case. The hard case is two vectors with the same dimension from different models: the arithmetic runs and the result is meaningless. The embeddings page shows it with this site's case UW-R06.
Production pitfall. Mixing metrics between write and read time fails silently. An index built for cosine and a query that sorts by L2 over unnormalized vectors can return a plausible top 5 that matches neither metric. Store the metric next to the embedding model's name, and check both in code before any query runs.
How databases spell these operations#
pgvector, the PostgreSQL extension used throughout this site, documents three distance operators, as read on 2026-11-18: <-> for Euclidean (L2) distance, <=> for cosine distance, and <#> for the negative inner product. The inner product is returned negated because PostgreSQL index scans only support ascending order, so smaller still means closer; multiply by −1 to get the inner product back. The README states cosine similarity as 1 minus cosine distance, and says that for vectors normalized to length 1, inner product gives the best performance.
sqlite-vec, a SQLite extension, sets a distance_metric per vector column; its documentation describes L2 as the default, and its vec_distance_cosine function returns a distance (near 0 for the same direction, near 2 for opposite), not a similarity, as documented on 2026-11-18. The detail matters for the failure above: two products, two defaults, and a cosine function that returns a distance. More product detail lives on pgvector and SQLite.
| Metric | Closer means | pgvector operator | Equal ranking to cosine when |
|---|---|---|---|
| Euclidean (L2) distance | smaller | <-> | vectors are normalized |
| Cosine distance (1 − cosine similarity) | smaller | <=> | always (same metric, flipped) |
| Negative inner product | smaller | <#> | vectors are normalized |
In a coding agent. A coding agent that indexes a repository stores one vector per code chunk, not one per repository. The question "where do we retry provider calls" becomes a query vector compared with each chunk's vector. If the index was built with cosine and the agent's query path sorts by L2 over unnormalized vectors, the top results drift toward short chunks. Normalize once when chunks are written, and keep the metric in the index's metadata.
A checklist for Monday#
| Question | Why it matters |
|---|---|
| Is every stored vector normalized, and is that checked on write? | Then cosine, dot product and L2 rank rows the same |
| Which metric did the index use, and which does the query use? | A mismatch returns a plausible, wrong top k |
| Is each score column named as a distance or a similarity? | Sort direction depends on it |
| Does a test assert the nearest row for a pair you know? | Catches reversed sorts and metric mixups |
| Is the dimension fixed in the column type? | Different lengths should fail loudly at insert |
| Do you store which model produced each vector? | Same dimension does not mean same space |
| Which distinctions must stay exact (version, tenant)? | Distance cannot see them; WHERE can (UW-R03) |
The cost of comparing with every rowN rows times d dimensions, and when it stops being cheap
Exact nearest-neighbor search, the kind on this page, computes one distance per candidate row. Each distance costs work proportional to the dimension: 16 multiplications and additions for the toy vectors, 384 for the model the insurance build uses. The total per query is roughly rows times dimensions. It grows linearly with the table and needs no index, no tuning and no approximation: the answer is the true top k.
The example measures work as distance computations, not milliseconds, because timings of toy Python are not a benchmark. In this site's case UW-R10, growing the precedent corpus from 40 to 4,000 rows takes exact search from 39 to 3,999 distance computations per query, one per active row. The vectors of the original 40 rows are unchanged; only the 3,960 new rows needed new vectors.
Linear work is often fine. With a selective exact filter, the rows left to compare can be a few hundred, as in the insurance build's planner finding, where the planner used a btree and an exact sort over about 190 rows. When it is not fine, an approximate index trades a little recall for skipping most comparisons; that trade, and how to measure it, is the ANN page.
Zero vectors, ties and deterministic orderEdge cases that make two runs disagree
A zero vector, all coordinates 0, has no direction, so its cosine with anything is undefined. vecmath.cosine_similarity defines it as 0, and normalize leaves a zero vector at zero. pgvector's README notes that zero vectors are not indexed for cosine distance, and NULL vectors are not indexed at all. A text that an encoder maps to all zeros, for example a passage made only of unknown words in some designs, can therefore be silently missing from an index. Test for it at write time.
Ties are the other edge. The Q1 output above has two rows at exactly 0.3035, because the superseded and current copies of R-ROOF-03 got identical vectors. Which one comes first depends on the sort's tie-breaker. The example's queries add the id as a second sort key (ORDER BY embedding <=> $1, passage_id), so every run returns the same order. Without that key, a database may return tied rows in any order, and a test that checks "the first row" becomes flaky. The real fix for this particular tie is not the tie-breaker but the version filter.
Choosing a metric is a model decision, not a database decisionFollow the embedding model's documentation, then normalize
The three-row table shows that metrics disagree on unnormalized vectors. It does not say which one is right, because "right" depends on how the vectors were produced. An embedding model is trained with a particular similarity in mind, and its documentation usually says which to use and whether its output is already normalized. The model cards read for this site, as documented on 2026-11-18, show their example code L2-normalizing the pooled output for all-MiniLM-L6-v2 and for bge-small-en-v1.5; the embeddings page covers pooling and normalization.
Once vectors are normalized, the choice among cosine, inner product and L2 stops affecting the ranking and becomes an implementation detail: use the operator your index supports best. pgvector's README says inner product gives the best performance for normalized vectors. The insurance build uses cosine distance on normalized vectors, which gives the same ranking.
What must stay fixed is the pair (model, metric) across the lifetime of the stored vectors. Changing the metric is a reindex: rebuild the index with a different operator class, vectors unchanged. Changing the model is a re-embedding: every vector recomputed. The two are different operations, and the operations page plans both.
From two dimensions to 384: what changes and what does notThe arithmetic is the same; intuition and storage are not
Every formula on this page works unchanged in 384 dimensions: a dot product is still a sum of products, L2 is still the square root of summed squared differences, and normalization still removes length. That is why the five-row lab is an honest model of a real vector query, not a simplification of it.
Three things do change. First, you can no longer look at the space. In two dimensions a person can see that row 1 is near the query; in 384 the only evidence of closeness is the number, so tests with known pairs replace eyesight. Second, no dimension has a name. The toy encoder's 16 dimensions are labeled roof, old, conflict and so on; a trained model's dimensions are not, and reading meaning into one coordinate is a mistake. Third, storage and compute grow with the dimension: pgvector documents its vector type as 4 bytes per dimension plus 8, so a 384-dimensional vector takes 1,544 bytes per row before any index. The model selection page weighs dimension against quality.
In one breath#
A vector is a list of numbers that places a row in space, and an embedding column gives every row its own. A vector query computes one distance per row, sorts the rows and keeps the nearest k, which is the same ORDER BY ... LIMIT k shape as finding the nearest store. Dot product, Euclidean distance and cosine can rank the same rows differently because of vector length; normalize the vectors and all three agree. Distance captures resemblance and cannot see exact facts such as a policy version, which stay in WHERE.
The agent can now rank rows by closeness once each row has numbers, and the UW-R01 paraphrase lands near R-ROOF-03. What it cannot yet explain is where good numbers come from: who decides that "aerial imagery shows an older roof" and "the two roof ages differ" should land close together. The next page, embeddings, opens the model that turns text into a vector, and shows why two models with the same dimension still do not share a space.