Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Add cross-engine search semantics regression tests (#83077)

Chris Truter8363349e12fb
diff --git a/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_test.clj b/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_test.clj
new file mode 100644
index 00000000000..f7c4f08e3a4
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_test.clj
@@ -0,0 +1,127 @@
+(ns metabase-enterprise.semantic-search.query-semantics-test
+ "Keyword, vector, and hybrid membership for the shared search cases.
+
+ Vectors are frozen output from the production-default embedding model, so the vector arm shows what that
+ model retrieves without needing it at test time.
+ The once fixture skips this suite when MB_PGVECTOR_DB_URL is not configured."
+ (:require
+ [clojure.set :as set]
+ [clojure.string :as str]
+ [clojure.test :refer :all]
+ [metabase-enterprise.semantic-search.env :as semantic.env]
+ [metabase-enterprise.semantic-search.index :as semantic.index]
+ [metabase-enterprise.semantic-search.pgvector-api :as semantic.pgvector-api]
+ [metabase-enterprise.semantic-search.query-semantics-vectors :as vectors]
+ [metabase-enterprise.semantic-search.test-util :as semantic.tu]
+ [metabase.search.query-semantics :as fixtures]
+ [metabase.search.test-util :as search.tu]
+ [metabase.test :as mt]
+ [next.jdbc :as jdbc]
+ [next.jdbc.result-set :as jdbc.rs]))
+
+(use-fixtures :once #'semantic.tu/once-fixture)
+
+(defn- indexed-documents
+ "Index rows for `docs`, with the searchable and embeddable text production would store for cards."
+ [docs label->id]
+ (for [[label {:keys [name description] :as doc}] docs
+ :let [id (label->id label)]]
+ {:model "card"
+ :id id
+ :name name
+ :searchable_text (str/join " " (remove nil? [name description]))
+ :embeddable_text (vectors/document-text doc)
+ :archived false
+ :legacy_input {:model "card", :id id, :name name}}))
+
+(defn- search-context
+ [query]
+ {:search-string query
+ :models #{"card"}
+ :archived? false
+ :vector-search-strategy :brute-force})
+
+(defn- sql-arm-hits!
+ "Labels returned by one arm of the semantic search query, `:keyword` or `:vector`, before the union."
+ [index query-vector search-ctx id->label arm]
+ (let [db (semantic.env/get-pgvector-datasource!)
+ query-map (case arm
+ :keyword (#'semantic.index/keyword-search-query index search-ctx)
+ :vector (#'semantic.index/semantic-search-query index query-vector search-ctx))]
+ (into #{}
+ (map (comp id->label parse-long :model_id))
+ (jdbc/execute! db (semantic.index/sql-format-quoted query-map)
+ {:builder-fn jdbc.rs/as-unqualified-lower-maps}))))
+
+(defn- hybrid-hits!
+ [index query id->label]
+ (into #{}
+ (map (comp id->label :id))
+ (:results (semantic.index/query-index
+ (semantic.env/get-pgvector-datasource!) index (search-context query)))))
+
+(defn- frozen-embeddings
+ "Select the frozen vectors for `inputs`; throws if any is missing."
+ [frozen inputs]
+ ;; The mock provider would otherwise return a default vector for a missing input and skew the vector arm.
+ (let [missing (remove #(contains? frozen %) inputs)]
+ (when (seq missing)
+ (throw (ex-info "Missing frozen vectors; run query-semantics-vectors/freeze!" {:inputs (vec missing)})))
+ (select-keys frozen inputs)))
+
+(defn- check-case!
+ "Index `case`'s documents, then check the keyword arm, the vector arm, and their union.
+ A semantic rewrite in a comparison is checked against the vector arm alone."
+ [{:keys [id config docs expect query comparisons] :as case} index frozen]
+ (mt/with-temporary-setting-values [search-language config]
+ ;; Temporary cards keep the semantic engine's read-permission checks live.
+ ;; Only the cards in `:docs` get indexed.
+ ;; The test indexes them itself, so automatic ingestion stays off.
+ (search.tu/do-with-labelled-cards
+ docs
+ (fn [label->id]
+ (let [id->label (set/map-invert label->id)
+ documents (vec (indexed-documents docs label->id))
+ rewrites (filter #(get-in % [:alternatives :semantic]) comparisons)
+ embeddings (frozen-embeddings frozen (concat (map :embeddable_text documents)
+ (map vectors/query-text
+ (vectors/semantic-queries case))))
+ query-vector (comp embeddings vectors/query-text)]
+ (semantic.tu/with-mock-embeddings embeddings
+ (jdbc/execute! (semantic.env/get-pgvector-datasource!)
+ [(str "TRUNCATE TABLE \"" (:table-name index) "\"")])
+ (semantic.tu/upsert-index! documents :index index :serial? true)
+ (doseq [arm [:keyword :vector]]
+ (testing (str id " " (name arm) " arm")
+ (is (= (set (get-in expect [:semantic arm]))
+ (sql-arm-hits! index (query-vector query) (search-context query) id->label arm)))))
+ (testing (str id " hybrid")
+ (is (= (fixtures/expected-hybrid-hits case)
+ (hybrid-hits! index query id->label))))
+ (doseq [comparison rewrites
+ :let [{:keys [query hits]} (fixtures/comparison-spec case comparison :semantic)]]
+ (testing (str id " / " (:focus comparison) " semantic vector arm")
+ (is (= hits (sql-arm-hits! index (query-vector query) (search-context query)
+ id->label :vector)))))))))))
+
+(deftest semantic-query-semantics-test
+ (mt/with-premium-features #{:semantic-search}
+ (mt/with-temporary-setting-values [ee-embedding-query-prefix ""
+ semantic-search-results-limit 50
+ semantic-search-min-results-threshold 0]
+ (mt/as-admin
+ (semantic.tu/with-test-db! {:mode :mock-initialized}
+ (semantic.tu/with-only-semantic-weights
+ (let [{:keys [model dimensions]} vectors/metadata
+ ;; The mock provider only looks up frozen real-model vectors;
+ ;; pgvector still performs the actual keyword and cosine queries.
+ embedding-model (semantic.tu/resolved-mock-embedding-model
+ :model-name model
+ :vector-dimensions dimensions)
+ index (semantic.pgvector-api/init-semantic-search!
+ (semantic.env/get-pgvector-datasource!)
+ semantic.tu/mock-index-metadata
+ embedding-model)
+ frozen (vectors/read-vectors)]
+ (doseq [case fixtures/cases]
+ (check-case! case index frozen)))))))))
diff --git a/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_vectors.clj b/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_vectors.clj
new file mode 100644
index 00000000000..75e691e8517
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/semantic_search/query_semantics_vectors.clj
@@ -0,0 +1,129 @@
+(ns metabase-enterprise.semantic-search.query-semantics-vectors
+ "Frozen embedding vectors for the shared search semantics corpus.
+
+ The semantic tests read these instead of calling a model. After changing a document or query in
+ `search/query_semantics.edn`, regenerate the file from a REPL with a local Ollama serving the model:
+
+ (freeze!)"
+ (:require
+ [clj-http.client :as http]
+ [clojure.edn :as edn]
+ [clojure.java.io :as io]
+ [clojure.string :as str]
+ [metabase-enterprise.semantic-search.embedding :as semantic.embedding]
+ [metabase.search.ingestion :as search.ingestion]
+ [metabase.search.query-semantics :as fixtures]
+ [metabase.util.json :as json])
+ (:import
+ (java.nio ByteBuffer)
+ (java.util Base64)))
+
+(set! *warn-on-reflection* true)
+
+(def ^:private resource-path "search/arctic_embed_l_v2_vectors.edn")
+
+(def ^:private ollama-model "Snowflake/snowflake-arctic-embed-l-v2.0:latest")
+
+(def ^:private header
+ (str/join "\n" [";; Frozen F16 Ollama output from Snowflake/snowflake-arctic-embed-l-v2.0:latest"
+ ";; (model ID 5de93a84837d). Query input includes the production `query: ` prefix."
+ ";; Document inputs use ingestion's `[card]\\nname: ...` embeddable-text format."
+ ";; Values are 1024 IEEE-754 float32 components in big-endian Base64."
+ ";; Decoding is local; no model or network access is needed by the test."
+ ";; Regenerate with metabase-enterprise.semantic-search.query-semantics-vectors/freeze!."]))
+
+(def metadata
+ "The model and encoding behind the frozen vectors."
+ {:model "Snowflake/snowflake-arctic-embed-l-v2.0"
+ :ollama-model-id "5de93a84837d"
+ :dimensions 1024
+ :encoding :float32-be-base64})
+
+(defn document-text
+ "The text production embeds for a fixture document indexed as a card."
+ [{:keys [name description]}]
+ (#'search.ingestion/embeddable-text {:model "card", :name name, :description description}))
+
+(defn query-text
+ "The text production embeds for `query`, with the model's own query prefix.
+ Matches production only while `ee-embedding-query-prefix` is unset, as in the semantic tests."
+ [query]
+ (str (#'semantic.embedding/default-query-prefix (:model metadata)) query))
+
+(defn semantic-queries
+ "The scenario query and any query rewritten for the semantic engine."
+ [{:keys [query comparisons]}]
+ (cons query (keep #(get-in % [:alternatives :semantic :query]) comparisons)))
+
+(defn- embedding-inputs
+ "Every text the semantic tests embed for `cases`."
+ [cases]
+ (distinct (concat (for [case cases, query (semantic-queries case)]
+ (query-text query))
+ (for [case cases, doc (vals (:docs case))]
+ (document-text doc)))))
+
+(defn read-vectors
+ "Decode the frozen vectors into a map from embedded text to vector."
+ []
+ (let [{:keys [dimensions encoding vectors]} (-> resource-path io/resource slurp edn/read-string)]
+ (when-not (= encoding :float32-be-base64)
+ (throw (ex-info "Unexpected vector encoding" {:encoding encoding})))
+ (update-vals vectors
+ (fn [^String encoded]
+ (let [buffer (ByteBuffer/wrap (.decode (Base64/getDecoder) encoded))]
+ (when-not (= (.remaining buffer) (* 4 dimensions))
+ (throw (ex-info "Unexpected vector length" {:bytes (.remaining buffer)})))
+ (vec (repeatedly dimensions #(double (.getFloat buffer)))))))))
+
+(defn- encode
+ [vector]
+ (let [buffer (ByteBuffer/allocate (* 4 (count vector)))]
+ (doseq [x vector]
+ (.putFloat buffer (float x)))
+ (.encodeToString (Base64/getEncoder) (.array buffer))))
+
+(defn- check-model!
+ "Throw unless Ollama serves the model build the frozen vectors came from."
+ [ollama-url]
+ (let [models (-> (http/get (str ollama-url "/api/tags") {:as :string}) :body json/decode+kw :models)
+ digest (some #(when (= ollama-model (:name %)) (:digest %)) models)]
+ (when-not (some-> digest (str/starts-with? (:ollama-model-id metadata)))
+ (throw (ex-info "Ollama does not serve the expected model build"
+ {:model ollama-model, :expected (:ollama-model-id metadata), :digest digest})))))
+
+(defn- embed
+ "Embed `input` with Ollama."
+ [ollama-url input]
+ ;; One input per request, so a vector cannot depend on what else shares its batch.
+ (let [vector (-> (http/post (str ollama-url "/api/embed")
+ {:body (json/encode {:model ollama-model, :input [input]})
+ :content-type :json
+ :as :string})
+ :body json/decode+kw :embeddings first)]
+ (when-not (= (:dimensions metadata) (count vector))
+ (throw (ex-info "Unexpected vector length" {:input input, :dimensions (count vector)})))
+ vector))
+
+(defn- file-contents
+ [entries]
+ (let [width (apply max (map (comp count str) (keys metadata)))
+ pad #(format (str "%-" width "s") %)]
+ (str header "\n{"
+ (str/join "\n " (for [[k v] metadata]
+ (str (pad k) " " (pr-str v))))
+ "\n :vectors\n {"
+ (str/join "\n " (for [[input encoded] entries]
+ (str (pr-str input) " " (pr-str encoded))))
+ "}}\n")))
+
+(defn freeze!
+ "Embed every corpus input with a local Ollama and rewrite the vectors file in test_resources.
+ Returns the number of vectors written."
+ [& {:keys [ollama-url] :or {ollama-url "http://localhost:11434"}}]
+ (check-model! ollama-url)
+ (let [entries (into (sorted-map)
+ (for [input (embedding-inputs fixtures/cases)]
+ [input (encode (embed ollama-url input))]))]
+ (spit (io/file "test_resources" resource-path) (file-contents entries))
+ (count entries)))
diff --git a/test/metabase/search/query_semantics.clj b/test/metabase/search/query_semantics.clj
new file mode 100644
index 00000000000..b4b8d281f12
--- /dev/null
+++ b/test/metabase/search/query_semantics.clj
@@ -0,0 +1,33 @@
+(ns metabase.search.query-semantics
+ "Search fixtures shared by the app-db and semantic test suites."
+ (:require
+ [clojure.edn :as edn]
+ [clojure.java.io :as io]
+ [clojure.set :as set]))
+
+(def cases
+ "The shared search scenarios, in fixture order, with their adapted-query comparisons."
+ (-> "search/query_semantics.edn" io/resource slurp edn/read-string))
+
+(defn expected-hits
+ "Expected result labels for an engine's identical-query search.
+
+ For semantic this is the vector arm alone; see [[expected-hybrid-hits]] for what search returns."
+ [case engine]
+ (set (if (= engine :semantic)
+ (get-in case [:expect :semantic :vector])
+ (get-in case [:expect engine]))))
+
+(defn expected-hybrid-hits
+ "Expected semantic search results: the union of its keyword and vector arms."
+ [case]
+ (set/union (set (get-in case [:expect :semantic :keyword]))
+ (set (get-in case [:expect :semantic :vector]))))
+
+(defn comparison-spec
+ "An engine's query and expected hits for `comparison`.
+ Engines without an alternative keep the scenario's query and hits."
+ [case comparison engine]
+ (let [spec (get-in comparison [:alternatives engine]
+ {:query (:query case), :hits (expected-hits case engine)})]
+ (update spec :hits set)))
diff --git a/test/metabase/search/query_semantics_stats.clj b/test/metabase/search/query_semantics_stats.clj
new file mode 100644
index 00000000000..caa5be3ac4c
--- /dev/null
+++ b/test/metabase/search/query_semantics_stats.clj
@@ -0,0 +1,99 @@
+(ns metabase.search.query-semantics-stats
+ "Result-set statistics for the shared search semantics corpus.
+
+ These compare fixture membership, not ranking or production query frequency."
+ (:require
+ [clojure.set :as set]
+ [metabase.search.query-semantics :as fixtures]))
+
+(def engines
+ "The four engines compared in each corpus case."
+ [:in-place :appdb-h2 :appdb-postgres :semantic])
+
+(def engine-pairs
+ "Ordered pairs; subset and superset counts are relative to the first engine."
+ (vec (for [[i left] (map-indexed vector engines)
+ right (subvec engines (inc i))]
+ [left right])))
+
+(defn relation
+ "Classify how two result sets relate: `:equal`, `:left-superset`, `:left-subset`, or `:incomparable`."
+ [left right]
+ (cond
+ (= left right) :equal
+ (set/superset? left right) :left-superset
+ (set/subset? left right) :left-subset
+ :else :incomparable))
+
+(defn score
+ "Precision, recall, and F1 against a correct result set.
+
+ Both empty sets score 1 on all three measures; a one-sided empty set scores 0."
+ [correct hits]
+ (let [shared (count (set/intersection correct hits))
+ precision (if (empty? hits) (if (empty? correct) 1 0) (/ shared (count hits)))
+ recall (if (empty? correct) (if (empty? hits) 1 0) (/ shared (count correct)))
+ f1 (if (zero? (+ precision recall))
+ 0
+ (/ (* 2 precision recall) (+ precision recall)))]
+ {:precision precision
+ :recall recall
+ :f1 f1}))
+
+(defn scenario-rows
+ "One identical-query result row per isolated scenario."
+ [cases]
+ (for [case cases]
+ (assoc (select-keys case [:id :focus :config :query :docs])
+ :semantic-arms (get-in case [:expect :semantic])
+ :results (zipmap engines (map #(fixtures/expected-hits case %) engines)))))
+
+(defn translation-rows
+ "One result row per adapted-query comparison, with its correct result set."
+ [cases]
+ (for [case cases
+ comparison (:comparisons case)
+ :let [specs (zipmap engines (map #(fixtures/comparison-spec case comparison %) engines))]]
+ (assoc (select-keys case [:config :docs])
+ :scenario-id (:id case)
+ :focus (:focus comparison)
+ :correct (set (:correct comparison))
+ :specs specs
+ :results (update-vals specs :hits))))
+
+(defn- mean
+ ([xs]
+ (if (seq xs)
+ (/ (reduce + xs) (count xs))
+ 0))
+ ([f xs]
+ (mean (map f xs))))
+
+(defn- membership-summary
+ [rows]
+ (let [results (map :results rows)]
+ {:count (count results)
+ :all-equal (count (filter #(apply = (map % engines)) results))
+ :mean-hits (zipmap engines (map #(mean (comp count %) results) engines))
+ :pairwise (zipmap engine-pairs
+ (for [[left right] engine-pairs]
+ (merge {:equal 0, :left-superset 0, :left-subset 0, :incomparable 0}
+ (frequencies (map #(relation (% left) (% right)) results)))))}))
+
+(defn- engine-score-summary
+ [rows engine]
+ (let [pairs (map (juxt :correct (comp engine :results)) rows)
+ scores (map #(apply score %) pairs)]
+ {:precision (mean :precision scores)
+ :recall (mean :recall scores)
+ :f1 (mean :f1 scores)
+ :exact (count (filter #(apply = %) pairs))}))
+
+(defn summary
+ "Summarize how the engines' results relate, for identical and adapted queries.
+ Adapted queries are also scored against their correct results."
+ [cases]
+ (let [translations (translation-rows cases)]
+ {:same-query (membership-summary (scenario-rows cases))
+ :translations (assoc (membership-summary translations)
+ :scores (zipmap engines (map #(engine-score-summary translations %) engines)))}))
diff --git a/test/metabase/search/query_semantics_stats_test.clj b/test/metabase/search/query_semantics_stats_test.clj
new file mode 100644
index 00000000000..4239f49fc59
--- /dev/null
+++ b/test/metabase/search/query_semantics_stats_test.clj
@@ -0,0 +1,64 @@
+(ns metabase.search.query-semantics-stats-test
+ "Checks of how the search engines' results relate, and how closely they match the correct results.
+ The corpus is hand-picked, so these numbers say nothing about production traffic or ranking quality."
+ (:require
+ [clojure.test :refer :all]
+ [metabase.search.query-semantics :as fixtures]
+ [metabase.search.query-semantics-stats :as stats]))
+
+(deftest result-set-relation-test
+ (are [expected left right] (= expected (stats/relation left right))
+ :equal #{} #{}
+ :equal #{:A :B} #{:B :A}
+ :left-superset #{:A :B} #{:A}
+ :left-subset #{:A} #{:A :B}
+ :incomparable #{:A :B} #{:B :C}))
+
+(deftest translated-comparisons-change-a-query-test
+ (doseq [{:keys [scenario-id focus specs]} (stats/translation-rows fixtures/cases)]
+ (is (< 1 (count (set (map (comp :query specs) stats/engines))))
+ (str scenario-id " / " focus " does not adapt any query"))))
+
+(deftest correct-score-test
+ (are [expected correct hits] (= expected (stats/score correct hits))
+ {:precision 1, :recall 1, :f1 1} #{} #{}
+ {:precision 0, :recall 0, :f1 0} #{:A} #{}
+ {:precision 0, :recall 0, :f1 0} #{} #{:A}
+ {:precision 1, :recall 1/2, :f1 2/3} #{:A :B} #{:A}
+ {:precision 1/2, :recall 1, :f1 2/3} #{:A} #{:A :B}
+ {:precision 0, :recall 0, :f1 0} #{:A} #{:B}))
+
+(deftest corpus-statistics-test
+ (let [{:keys [same-query translations]} (stats/summary fixtures/cases)]
+ (testing "same query, with pairwise direction relative to the first engine"
+ (is (= {:count 40
+ :all-equal 5
+ :mean-hits {:in-place 29/10
+ :appdb-h2 31/20
+ :appdb-postgres 67/40
+ :semantic 23/8}
+ :pairwise {[:in-place :appdb-h2] {:equal 20, :left-superset 20, :left-subset 0, :incomparable 0}
+ [:in-place :appdb-postgres] {:equal 6, :left-superset 28, :left-subset 4, :incomparable 2}
+ [:in-place :semantic] {:equal 21, :left-superset 11, :left-subset 8, :incomparable 0}
+ [:appdb-h2 :appdb-postgres] {:equal 11, :left-superset 13, :left-subset 13, :incomparable 3}
+ [:appdb-h2 :semantic] {:equal 8, :left-superset 8, :left-subset 24, :incomparable 0}
+ [:appdb-postgres :semantic] {:equal 8, :left-superset 3, :left-subset 28, :incomparable 1}}}
+ same-query)))
+ (testing "translated queries, scored against each comparison's correct result set"
+ (is (= {:count 18
+ :all-equal 1
+ :mean-hits {:in-place 11/3
+ :appdb-h2 26/9
+ :appdb-postgres 41/18
+ :semantic 10/3}
+ :pairwise {[:in-place :appdb-h2] {:equal 10, :left-superset 8, :left-subset 0, :incomparable 0}
+ [:in-place :appdb-postgres] {:equal 4, :left-superset 13, :left-subset 0, :incomparable 1}
+ [:in-place :semantic] {:equal 9, :left-superset 6, :left-subset 2, :incomparable 1}
+ [:appdb-h2 :appdb-postgres] {:equal 5, :left-superset 8, :left-subset 3, :incomparable 2}
+ [:appdb-h2 :semantic] {:equal 6, :left-superset 3, :left-subset 8, :incomparable 1}
+ [:appdb-postgres :semantic] {:equal 4, :left-superset 2, :left-subset 12, :incomparable 0}}
+ :scores {:in-place {:precision 2623/3780, :recall 1, :f1 426677/540540, :exact 6}
+ :appdb-h2 {:precision 223/270, :recall 103/108, :f1 35779/41580, :exact 8}
+ :appdb-postgres {:precision 89/108, :recall 23/27, :f1 2449/2970, :exact 11}
+ :semantic {:precision 83/120, :recall 95/108, :f1 9643/13860, :exact 4}}}
+ translations)))))
diff --git a/test/metabase/search/query_semantics_test.clj b/test/metabase/search/query_semantics_test.clj
new file mode 100644
index 00000000000..ac2281eff21
--- /dev/null
+++ b/test/metabase/search/query_semantics_test.clj
@@ -0,0 +1,87 @@
+(ns metabase.search.query-semantics-test
+ "Exact result sets for in-place and app-db search on the shared search scenarios.
+ Each scenario and adapted query runs against temporary cards or a temporary index table.
+ Assertions compare membership, not ranking."
+ (:require
+ [clojure.set :as set]
+ [clojure.test :refer :all]
+ [metabase.app-db.core :as mdb]
+ [metabase.search.appdb.index :as search.index]
+ [metabase.search.appdb.specialization.api :as specialization]
+ [metabase.search.engine :as search.engine]
+ [metabase.search.ingestion :as search.ingestion]
+ [metabase.search.query-semantics :as fixtures]
+ [metabase.search.test-util :as search.tu]
+ [metabase.test :as mt]))
+
+(defn- result-ids
+ [query raw-ctx id->label]
+ (into #{} (map (comp id->label :id))
+ (search.tu/search-results query raw-ctx)))
+
+(defn- check-in-place-query!
+ "Search only this case's cards, even for queries containing LIKE wildcards."
+ [docs query expected]
+ ;; `:ids` excludes the filler cards, even when the query is a match-all LIKE pattern.
+ ;; These cards are queried directly, so they must not enqueue index updates.
+ (search.tu/do-with-labelled-cards
+ docs
+ (fn [label->id]
+ (is (= expected
+ (result-ids query {:search-engine "in-place"
+ :models #{"card"}
+ :ids (set (vals label->id))}
+ (set/map-invert label->id)))))))
+
+(defn- index-documents!
+ "Insert this case's documents into the temporary app-db search index."
+ [docs]
+ (let [label->id (zipmap (keys docs) (iterate inc 1))
+ documents (for [[label attrs] docs]
+ (merge {:model "card", :id (label->id label)} attrs))]
+ (#'specialization/batch-upsert!
+ (search.index/active-table)
+ (map (comp #'search.index/document->entry
+ #'search.ingestion/->document)
+ documents))
+ (set/map-invert label->id)))
+
+(defn- check-appdb-query!
+ "Build the case index and query it with the case's text-search language."
+ [config docs query expected]
+ ;; PostgreSQL uses this language for both indexed tsvectors and the query.
+ ;; H2 ignores it for matching.
+ (mt/with-temporary-setting-values [search-language config]
+ (search.tu/with-temp-index-table
+ (let [id->label (index-documents! docs)]
+ (is (= expected
+ (result-ids query {:search-engine "appdb"
+ :models #{"card"}}
+ id->label)))))))
+
+(defn- available-appdb-dialect
+ []
+ (when (search.engine/supported-engine? :search.engine/appdb)
+ (case (mdb/db-type)
+ :h2 :appdb-h2
+ :postgres :appdb-postgres
+ nil)))
+
+(deftest identical-query-semantics-test
+ (let [dialect (available-appdb-dialect)]
+ (doseq [{:keys [id focus config docs query] :as case} fixtures/cases]
+ (testing (str id " / " focus)
+ (check-in-place-query! docs query (fixtures/expected-hits case :in-place))
+ (when dialect
+ (check-appdb-query! config docs query (fixtures/expected-hits case dialect)))))))
+
+(deftest translated-query-semantics-test
+ (let [dialect (available-appdb-dialect)]
+ (doseq [{:keys [id config docs comparisons] :as case} fixtures/cases
+ {:keys [focus] :as comparison} comparisons]
+ (testing (str id " / " focus)
+ (let [{:keys [query hits]} (fixtures/comparison-spec case comparison :in-place)]
+ (check-in-place-query! docs query hits))
+ (when dialect
+ (let [{:keys [query hits]} (fixtures/comparison-spec case comparison dialect)]
+ (check-appdb-query! config docs query hits)))))))
diff --git a/test/metabase/search/test_util.clj b/test/metabase/search/test_util.clj
index 463596f94c9..c95104d893e 100644
--- a/test/metabase/search/test_util.clj
+++ b/test/metabase/search/test_util.clj
@@ -8,6 +8,7 @@
[metabase.search.core :as search]
[metabase.search.engine :as search.engine]
[metabase.search.impl :as search.impl]
+ [metabase.search.ingestion :as search.ingestion]
[metabase.test :as mt]
[toucan2.core :as t2]))
@@ -16,9 +17,28 @@
(defmacro with-sync-search-indexing
"Perform all search indexing synchronously."
[& body]
- `(binding [metabase.search.ingestion/*force-sync* true]
+ `(binding [search.ingestion/*force-sync* true]
~@body))
+(defn do-with-labelled-cards
+ "Create a temporary card for each entry of `docs`, a map from a label (`:A` to `:H`) to card attributes.
+ Calls `body-fn` with a map from those labels to the card ids.
+ The cards do not enqueue index updates."
+ [docs body-fn]
+ ;; `with-temp` needs fixed bindings, so it creates all eight; absent labels get a filler name.
+ (binding [search.ingestion/*disable-updates* true]
+ (let [missing {:name (str "zzq-nonmatch-" (random-uuid))}]
+ (mt/with-temp
+ [:model/Card {a :id} (get docs :A missing)
+ :model/Card {b :id} (get docs :B missing)
+ :model/Card {c :id} (get docs :C missing)
+ :model/Card {d :id} (get docs :D missing)
+ :model/Card {e :id} (get docs :E missing)
+ :model/Card {f :id} (get docs :F missing)
+ :model/Card {g :id} (get docs :G missing)
+ :model/Card {h :id} (get docs :H missing)]
+ (body-fn (select-keys {:A a, :B b, :C c, :D d, :E e, :F f, :G g, :H h} (keys docs)))))))
+
(defmacro with-temp-index-table
"Create a temporary index table for the duration of the body.
diff --git a/test_resources/search/arctic_embed_l_v2_vectors.edn b/test_resources/search/arctic_embed_l_v2_vectors.edn
new file mode 100644
index 00000000000..7af388d79ad
--- /dev/null
+++ b/test_resources/search/arctic_embed_l_v2_vectors.edn
@@ -0,0 +1,121 @@
+;; Frozen F16 Ollama output from Snowflake/snowflake-arctic-embed-l-v2.0:latest
+;; (model ID 5de93a84837d). Query input includes the production `query: ` prefix.
+;; Document inputs use ingestion's `[card]\nname: ...` embeddable-text format.
+;; Values are 1024 IEEE-754 float32 components in big-endian Base64.
+;; Decoding is local; no model or network access is needed by the test.
+;; Regenerate with metabase-enterprise.semantic-search.query-semantics-vectors/freeze!.
+{:model "Snowflake/snowflake-arctic-embed-l-v2.0"
+ :ollama-model-id "5de93a84837d"
+ :dimensions 1024
+ :encoding :float32-be-base64
+ :vectors
+ {"[card]\nname: \"amber and cobalt\"" "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"
+ "[card]\nname: \"amber co" "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"
+ "[card]\nname: \"amber co\"" "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"
+ "[card]\nname: \"amber cobalt\"" "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"
+ "[card]\nname: -cobalt" "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"
+ "[card]\nname: 100% complete" "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"
+ "[card]\nname: a b" "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"
+ "[card]\nname: a-b" "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"
+ "[card]\nname: a_b" "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"
+ "[card]\nname: ab" "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"
+ "[card]\nname: acb" "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"
+ "[card]\nname: accounts" "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"
+ "[card]\nname: amb" "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"
+ "[card]\nname: amb cobalt" "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"
+ "[card]\nname: amb or cobalt" "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"
+ "[card]\nname: amber" "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"
+ "[card]\nname: amber\ndescription: cobalt" "vReIwjwD7ca8DROMvP8EZbyTzQS9QOXCvDm1pTzxv/M8nfZ5vNK0qz1BPYo7BlHWPSI1YjzxOkM89fbXPYvpY70OJL+8VKw+vUFHHbwl+qW+EU4lPbpMQ72cpi09Nur7vTOBALyDgem8MxrkPOarRLyrgTo8fXpZvTpfir1mU1O8cbw6O4/gVryhRXM8AgMKPCRArT2H4iO+Ok/tPLUUPr0fHy89Ist0PKtkATymrLU9HSCEvK55z70roZS9k8WAPS/YaLzN51O7VmMZPKAKjLwBMHw6WzGEvIBom73JLLm8tu7DvR0gJz2Gh729D6diPSDgezyV77C6oG4QO/immL2Hq7k9AwewPVphPzwgFXc7GsE8vK9gM7yfaNy7wMf7vZtw+TzFHoG9fQkVvMtoZznxfZw8+aVHPCypCD0T6Yg9tlxyPHqd7zzAEpG7N6VSPQ8x+T01Bwi9YIHCPUft4T0b7c09V7xFPOtbebz2df49W8Qzu6KmkbylByM6gzrZvUGcNjyoGlQ9XNmpPTUd4bw8r189tJApPLp4Ozz6ibY89SeOvaQodjyx+VM8ivMwPAo1v72cmU09eLV5PE3h1D1tSF89KPe1PP+UMz0Lze47HzMPPcmDF7ztJSo8oNSLvPYBrLqszkI7P5j1vOK7Nr2dcYy7xxYmvZhTkDyUkMS8UzQjPL1XGT1Cc5G8gYa6uy3Trb07Ybu8/QVMPThdFL0bzwo8iyZxvPamCLyGkoG67/OXPC/sUrmYem69PvDiO6KRBj2O5V89j8/aPE+moLsdAWK9J3QXPD2NRLy1Jri8jY/dvVrWaTw3IDu8j/RwPI35l72zUWG9CGeXPOm1CTuYbcm8964rPWFNBr2z2t27yNrrvKDdpjsImsY9EQ24PY4tR7yn2dW8MYVEPYYuwzyJ05C8DjJsvMTCzT1RrDA9PGtavSi91zxBiwO8t3xBu9C6z70FPeO8kO9svUobvLzMo2S6JiGZPT3ydjyBt6O9jPYEPQRKP70xmE49GFwrvPbaRby7W2E8trU7PTCdH7xMKhe71OnPvQkN8bxeOOq8ls58vaVoSj0yPxS9GQrlPXyH3jwy6h+8ykyFPYI8QzvBwyW9LiInvYMueDzjkHQ79FzHPYX+Irzd/Ya7nsLsvKEPMzxnxWq8y7IPvF8wmj0biWc77D7mvPP8Jj2l07E8En1UPHKU5Tu20GU9l+/8u9OtRD0DiWm9RhvfuplItrz2uo09qoAxvRua/rxOo3I9aeLsO4lrw7yiDl+9iVJuvTQF8b0DDJW9KnGSPNPhUL0EQuE9D9aUPTN4PjpVphm8pg5xvTX/MLxQwZS9MyfKPUN8cTyU6Dq8DFqlPadXzLxQ3MY87G+6OrgigDuVTVs8972mvMjTlDxlJmk9FF9EPMlvJ7uKOcc8f38BPVhyqjxr/qS8dbimvDbetDpWTya8PrigvKIMkj05OY48Lhn/vNV8przSycs9RawtPB3gsT1Y3S484Hr7O7kynz0jW2o9MipRvL2DMjzksYi8qy2kPI8Hub0fPjO8Z2uWuuP7Xj0CriA84d6aO6Votzna4UU7BdM0OZG4gzumMr48xpxOvLvOLzxW+f89NiwWvDYQOjySHXC9DZEOPM962LwBen28klizu14fXb1PeWW8aFjwvSGierwvDUA804lHPKsFObrS8Gm9KiDqvSpvwz2GcU49AnwqPICwILyYYSi9ZWe5vRBf/rq8CfO8dbCyu6EnZLxs1sq8q/iou6PSGL0HFqq8L80HvCT5e7prMui8sHiGO0RCwjwwkM28XsHsPFaINDwBYBa7Y717PQWGBTwBNN09SyOJvHhzMzwzmFK9CcU/PQBGwbzgZ2S80bxyvO/g4j0b+9887SBPPEw/fT1VCn+8GgIZvDP1M70UhhW78LD9vJN9lT03lai7RJn5PEXp47vAw8882e9qvALhZj0WprU81xOCPLDMYbvL1pK68yovu45wwDqchaK8h1SyO9UhZzt+mrQ7raVMvMrC8Tv6R6g7woGrPKLzYjwhv887g3fMvMAiQjzZh6M9Elv9PHyRI7117tK9BLT2PG6bazz9bdU9D0BgvHda1rw/MOm8g2P0us/fPb0HicA8zs6+vAalYr0bzRI8yD5YPPmVBLuYLSc8pA31vPa1GjxOv4g9ESOoPU0fbb0lUq+811nnPRgs0D0d/XC8OHf0u7JbRT2V+gU8Xm99uzGynryHIpq82MkpPN7ESjnAfZ+9fx1ovQ+fYbvqP0G66XmqvFziVrybMKw7ujsnPA3z6rvQOQu6XjLNPLkUqrylG6Y8vuxavOCqmD0eidy9mDCuvDu4wjzC3P48nsc0vQKAYbxD0ni9ahL4vOFIITyjWBg7amRvPFwHEryZ3hQ8P23dPIaQIjzVir08tp/GvTHlhbv6m/e9MtJPPB93sryiL2W8oSijO+SbgzwKDOy9RbchO/5WcbyS8MW8kBfXPAOCJjqNjq48xsnpPHTKzDzsIYw8uZKhPT5Udz01KeK8E46QPFqBDr1Nh3k8uU2zvCgu9Lq6UJU8KUEtvK5tg7xT3Go8ocVWOpUpg7yHlzo8nrpMvAeGLjw/tRG8pSHHvUiOBD2FGhM7rN6wPKM1rjy5+Qe9M/mNPCVBsTx4XiY9QZ8zvQCXIT2j6w87l2FHvR6YDbuE7ce8rdRQPKiNTjxTwEo88dj9PFcHhDwtw9S6tkNFvRD5Qrs3UDa7gEFxPZmolrycjrO8yUvUPTf5XLxqX7e9GJo1Ol3I87vvQSy7P2qDPBXY4rsCDIG9H2gMvP4LPjzJAG47L4EvPNLd8zxHqAW8Fqizu+r0vjyH7dU85YQpvI2ZbzzdPvO9E/V0O1LRyDrgQiC8h9kpvOo/OrukL0g7xLOtPHQ9yrw/6M68BtDoPSeomby+M589QQgbvJCfxDwT2mg9D955vRpesbym1Zu8hT/lO+oAB7z8Qem9Di0du9gI2jvNz0y8crIFvMWptD10Jf27irXxvB4iwrtiX5S8/Z/XvIAQp70G+Mw87Kucur5B4TxJ/tm7hEUpOxhkmDydHHS8epcpPMX9VDy5FjG9RpmbvSs2HLwFC9g8ygM+vWwEMDywK5k8mPlcvGp1i7xX43c8Knk2vCybhr0FFd66Lop8vU+sVLx6kQM7tvo3O63lEj0Zhx48Z1/gvA4Srj0UQXm8TLhsPFJkdzzQeKw75lTwOg7nCTyz80m8sIJkPMBnoTs5ShC8F6GvPV5mwLsObHg7h0QpvFkCIrt9mkM7FnYzvQNuBTqbD1U8+L6PPASXlz0GoZG75BImvYNmNLvTVAM9jBJ6PAwkiLo/uDc9K2J6vLdk67vwGv+794IMvEEFPT06OEG9EWVzu4m7WjxWGaq76XxcvI36Jr0hc7a9SHnQPLPvOTyoD9m9Imp1PEAqQj0CUCa9At6kPKUekj0Q3f89BZLju69Ggr1HJbu9cmZ5vG9MdLu9B+y80kpfvIS5a7wZKb+8KwVvPAcGdbtQPZ+7oHwjPJc92r1khrq7N2Z3PV/sEbzWpLe8qlQRvQBCNjyJIta9Ju0RvSyD3rvjXqk8845JvO/zFjuy4iq73HrJPMJgmbxXKou81FjCPP998D13ukY81+jVvZfPnjtn5BS7gPi+vQ0gfL1EvV88cyz5vIVubLyd7Ua9Xu0UvGHHXrwZn4q8k4AvvPgibT2ScOq8zF5LPJitQTqcBCs7Ii/wPK3AaLyE53S9dN6NvWiAmrultVK728eau4/nRz0PFDi82XfDvLrVlj0TRb09LqZyPOG0fryReAa9j9vgO7dkKj1PVMc81vOtPOuiNrrx3/m8DNj3PLidHzuhukc8sdlmvKDOKrt0oz+9JKd0vDvgkDzLC4k9JNtfO8jZrz0N5OM7gyqqPOYCjTs3N8M9PdOavbNwfDz68hO8xQR9O/G02ryrC7s8HsX2PIip1jyv4oQ8ExgIvSLILr0A4qE9eA17vMOpLTzDrYY5WdSAvHXEgryQNlC8/9kZPJ+cCb2ZkBA63OLzO9fo+bzLRH+65xOePA27A70Me+M9AJ2rvGbH1bwLZd69PGHkvS7bG7pYWm88xglkPKp6Rb0E/fO9FLxlvBqsx7s1d3I72w5hPRoJBLzDCJq8yy7Du5eicrwvSuC7+oRJvDNQeDzx/2u8NproPJAaO7y3abY9A27fu9+VWr0Jeii77W6svQZfhLw1wRK9OB7WPCZMxDxeqv+8FltOu+yTjjz3YXm8oCqvvLIBYTzuiDw7AQRIvR3zrjwFrbk9G5UOPKgY5jw+BcW74a8sPMPJ4rpesFI9n98yvE6McTywHbC8C3RMPVcuFzxu39A8bHHdO/yYS72K4iW9N6WNvC9zZjzf9Kk8ODI6usgupLyOExo9kl8Su947ez1ZDZq8iVPIvEL9ITzGEbS8iWsBO5Lu17yg16q8j+FAPS8uDr0XUEI7uJT5uw5DPTxP+xk8VVPouyj/CzwFIyi8z2rxvRaGRryRz/M8E+QSuyA9Nj0ds167SV9hPHMpMTyJoIo9IRamPHMNdD3Wl8o6iKdTvAxmbjwakLU7ObcDPIz2jrqMafm9AKaJO28SubyC8rs9A1BRu9C3u7x1UeK8pdFyPDZ+wLyfbhk8gM1FvQqylb0SzJ28bRSRvKaBPTyv6iu61Jc+PCi+tj0TtfK8fqPduUJ6CjwP/Ry8RL+EOihobzttO4G7zhUuPLDWmz0BUa08mPLAvJ0AE7r92Q+9E0vlvOElN7yCDYQ86UkdPQ1Axb18Sug8nbfIPCimlDwXfZw8K2T7vGoEPTzxUmY7pPlsvIyRxzwk9BY8+izovQDQDzvWS9O8ZLYqPELyCj1AMSs8oJbAPTjXuLzR1Ju6eX/au/6SCrsx/As8zK9tPI3gqTx6FP89fBYEvFd0PzyGiUk8LXE8OxaJJbyW7Bk8owOivOMlfLzTLkG8bcLpPAm9XDy2ROO7g9tHPJAgIr1loxQ9WhhZvBrtxLuXGGS8g6FJu5GTgbzpKAw8JlrJu+QWMTxrVGa8V/wUvMnGYLwCwy+4hU+IO7+gIL1D2og8eMOtPFOUGjuVLye8z21ZO+5hfjwNzhk8mALTPDSk3Lw/8Lc7wyMkvPcqWTwLHGG8+vm+POUL0buf3gK9cDIEuwKCXLw3/WW9HBgnPGlYfryM0KG9GVwuOyyECDyG+wU9HtNxvKlifL0viYA8HABOPXo6LjxiPnK9NYBePYJbRz1Qrwe8neBePNSREj1G+py8o7V6vJ46ALyUjRo9SEL8vSscsj0kFIQ9C9u9PCaLLDyPbmW8waqmu82upjxzx6w8aCUoPUVYHDxUORM8DUnuO5AwBbvm6Za7isKwPaFRBbzGe6I8ClszPN5YDr0URH47QLmavRL62TxaJEA8lB0jvLftvDuJ9GW7kvS5vMzvITzj14m9HvrzOwxkM7yLKmS68+BvPBz/xg=="
+ "[card]\nname: amber -co" "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"
+ "[card]\nname: amber -cobalt" "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"
+ "[card]\nname: amber and" "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"
+ "[card]\nname: amber and bright cobalt" "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"
+ "[card]\nname: amber and cobalt" "vRMtCTxR+Z68j9l2vM+uaru9diy8UnVnPIdP+jzKvHM9DvtTvKSqQD1LK5U8rCjKPVa1ZzybMDS7w+vcPOzyP71BYPm7ZLngvXxY6LzBzSu+DnIuPdRe+L2YUkA9Ai2bvUvYSLzefwm8ItWZPZtBi70Q/qY86WO5vTJzV72DjuS8oYNZOqKYzjwR5LM8ctLvu4SHFz1k6RG+L/AWPIrxF71ZiAo8wnv0PQ1v5DmrQMg9E7J1vAPXpb0MyL69jh2CPRZvdr0OPic8ZbqJPU5DLDyGHH28EZJ1vKMd272Om8G9JrxAvFpI3z03esu8pCYcPYfFGT0Qsj48zuzTO4M+2L3Wqs48q3EIPSfDoztlj+28lLgTvMUxF7yxurU8Sp2jvY9nGjx3m0i9QdROvSbLGbtWIuE8NKm8PQA/TD0HRfA98vatvI0dnTvxJ5W7n9q4PQwsuz0uAAC9OdmxPV3k7DzEXuQ9fqcEvA7ESbypvN48t4JLuzMIxrxrwv08LULRva9nXzvXgI08vKN2PPfdhT0Xw7o9tbqoPQ9ADLwtTXc8s65avUUyYjwmOAo8srIlPOp9oL2Sj5c9kW3RPCa1iT02uyE87RzkPBNHeDzV0Zs9JguPPZXB77u/Dg884KD4vQwatDojdfA8Ha+ovToEj71PiFK9HgwivTFO6Tv5rAY8xOy3PMB+iT2KZnm9JRI4O45rgL05LxO8ra45PWFkSbzetYS7FgGVvQfJYbziDKc8J4pxvIv9Mzx2zqa9AKIlPMs1zz2oiec9b1RZPQ9XLTwGPuG9G9lvOxGo1r0WJQe8cEbrvY6W3rxt6NA6/EUku7XzG72AcsO8kn8QuAhWsbxw6f69OGcJPbUFsr1mpAy8ETyOvCgcljtVdSQ8yR56PbXabrylUue8wZiIPU/VxTxE1ry83XxvvL94ZT136D08MDWwvU4GO7uqcZS89WmGulCjQb0gvgI7UsfZvWJ0jjtsz8G6E3OnPWmyYzyNSjq9GKDpPSOgm7zukMY8mdhTvDfwM7uf2Sw7/Vd4PYaOzruAPtO9AsyIvKMOzzntDJG9JEnRvfMSljz4qai9Ki0qPZE/6Ty+N5a8jSc9PRYeNzxVWcW8tBjMvaMj5zxwlHe7h0SpPX9Plr0S+1i8W9sNvFWL5TzvXg68f85+O6k1/TzMGP49A+A7vGV1/T3c3SM8hM5dPHfL0jqYo+Q9vLFPu3fR0jyFRMe9o5XkPGjjwDvLG0c9pMhUvVITIzwlQCE9DlQ1PIVXFL1m4U69hzdJvMMo07yY6L28GHsyPT1CXLz5yLE8rwHnPRzERLsvbBq8kn59vVYseLx7me+9lXt7PKExRDzshwK8yAcsPYGZ1LwoxS48nIAoO9m7EDynkEE9MG5dvSUEmzu2ggA9FBh0PLGikbrqVgg6CjGCPRCDSTwDYQ+9A7FnvGU5vTo1pE+8hGwVvQCxGTzvpeq79pWnvAqFCLzBYKA9N0vPusFpFT0y7so81Y7nPDn6RjzrXZw826pZvP/ShTvXaEk7Wkj2vANMs7wNhBq8DeK/O916Qz0F5/Y9TY9gO9mUCLuDWcE8Tk8zOZQxE7sg56A8lHQtvHndLruaR1Y80FA6O7e0AjwmcDa76EBtPJfgYjrZ4Tm8PnJ1O4p7Xb1l2cm6pfpcvSXirbtfbU88CBrbPKWIWrtH6X69Xz9qvXHyxD2nYns8qgCDOoosGLu/SK29Z6I5vBVqKzuYM2+7xjfGu2frTLxCPUK88gxavM8oVL0TMgY68hUju8nzeDqgJy28PPHUudMyxzyPIJo7HXhYPOo14zoa3aQ702aYPNpLcTx30Wg9Q6zavEqS3TyTJLK86HVTPI46Wbwttmq9QpAOvKZEUT0k78s70tQpu2mALj0ypSq8RVoPvD0WVrxuXva8mRH0uqZ+Zj0Xqza8MvwRO1Epf7xE0Ik8Vm+8vBqJSz1Hjb49DJaiPFbrHr0MrYG7y411vCcCVrptvmu7q9WlvBV41DuZN7Q8qcSRvJdfcbxRKJI8Lc8NPLk7Yjx+tV+8Q+OivPizxDxJJF89Gqb8O9uIpL0hLvC9KbE0PSFTGjyfyHA9PxCDvQslQLypEJq8iKXNu3U/or0nE508k03LvCW0AryLQc083IHnPJuSyTpLbZo8mPD2vJOS0rwss+s72AcvPU+fSLzE7HG9DuUZPL0bNzzIY4M8uzXlvB/pKD2D9748RD5Iu23UvLwGUey7FO5hPR8eRDwdqZC9iFj8vQGtATxEI8076WR1PIZxIryaC/E9A+RVPLJvRbwdEeq8ezFnPNUZ6byfKTs9A84avSVl4z00jqO9b7mwvJ4AjDzitfg8nnApvTnrvbrBKHW9hIlCvD6GHTyLjsq8iliuPJzlNb0FydU8pgoXPIRYCzzh8IA8pdcbvODp+Lxto8+9gD4FPJn6s7uL08W8ueBXPK/eajyJ0GW9BXYvPKHJT7tytau79yMbuwOlDzwDn3w8swyyPLHpkDzEr5s86vFwPRzapD0cN7+7KNI2vBmrWLy3vA48lqQ/u8ILeDyr3by8j22YvM4oWLzD9fE8gQ0uvBpepLwsunM82T9jOptauDzHh5a8kug/vTuUmT1mP+o8IKlaPIeTbzqdvIG9OXpyPEs5aTznyZk9jMbMvKrQXT2XPGe6TtFGvUz68bxRxGO9AECYPNMptjyKF3s8kN7uPI+NhrwQRKc8YIjnvSBvfDs+Z2C7vYOcPZJ5oLyBrtO87FzCPR2pX7zMS8W833E1u4PjyruxxgO8EhkAPIfmYDwuE9O9GlsxvQrxQTzcw/c6oxbfO9uIuD0LK4Q7Uf87OjOhGTyhexc88LxxuzzclDwjMM69QiL3vLQ4e7m19Uy8wURzvRDTHjsqXMg8sfW/O+vsYTswV/C8uLcwPWO6vbyI5g09QkD+vDA+SzzhOSg9LlZjvDWkyrvHaTE6frkPO8bLNb0i0zy9DrKxvKlxGTxQA9U8t7XYvQRVzD18gEA8Bq8tvGmf9jwZxky82DJoumX/870LJe88nj+CuzTtozuHkq67o6nzvAfDqrs6pTy8+bC4PNrjozw7ODi8/yi5vQgVarxH8/M88hWDvUMqmztAfp48H8InvUizrLz5tNI7+SffO34PdL0jGpm8wb6SvWLWH7yktUu77cLLPHy3eD0kX2g8V6npOwUTwzy8mDu7LYq8PGNHlz0so0C7N0J+O2DX/7uhIY69EgGcPAz+3jxW1No7dRTaPST9I7rTErO6HxlJvLYfqDyLEOe8wgODvN86HDpzJB88YyECPBxY+D0LEl08GxETvVa8SDxe/Cs9VKTyPOUNWDyrqJQ9KZTfus6unLzbliK8e0cPvAC1uT1k8KS9LI+pOduIRzzwZg26UJEdvDKh/7sEJOi9C0vuPIG79jytTxu9JDvtPFNmETz54yy8pD86PF4nZD0Jths85In7upKPH70sLb29G26FvQnvDztUnMW8AQU0vCS2vLxbNzi8qKGiPKoUJLwkLEw689PMPVDXJL1Wj+g8rLuCPZsViL0GMZw7LsqIvM71KTwTrva9MTNTvOgMw7xv+ks9SnwRvF29Kjt9osK8JplHPIE2wr0JUwa8b0bIPL2RfT18wXM8IYLwvZxu8zzRdDy8VHq4vJVH8b1MnRE8F5dtvJsmKbzDQQy9I0jvvJStE7u8geu83CVFOoRuAT2XzsS8zmCEPO/Ff7wfSRG8QuY+PCcfPbz0Qki9chhCvW2oELr/u887VFpdPCzsiT0HqnG9TIT3vL5xlzzuSq89efDwPD+sR7ou1729N/f0PEzefT0mnTo8+yA2PGlzZ7xJbtq8ZBlDPOhVETo76Qc8/yVlvJLverwwrVa9WDDMvHmHnD0PLSk86D74OqGFzj0oMgq9IXuTPRaSfzwhHXw85Twmvap9nD0+ovS9Blpbu9nM/rzwDmM8mjlMul8+NjuL2IU8kZDHvGcknbvwEZs9a6swvNHaUTxvPqs73hXMvNaLV7xssr+8+DrGO9ecer2JLHe8ENceO9DNYr0GIW+7jizONqMXubykIpw9dTrKvEWOm7zJSiG8uavCvUao+ruPoEY7hz4yPQNqcLz82oW9D1sQPQbzLTrccHA8ssuPPRDSLLy6bcG76PSePFcQL7wAg/k8Brq+vHb93jyd7d68pNjdPKHl9LzAvZY8ncElu9S1rbzdAEi829AIvOSLkbzx/VC9cHfsPOCsWTv3zjg7Jky4O0PVlTwwe7O7qWDDvMOegTySAW078ZcVvTYGfzxP5nk8wD0aPDqw9zxIMg67wZISPQw8T7u4c6g9qwUavMMJnLwJF7W7jtLJPX3X2jxtRMU8MKRkPCU1wr08bcK9TWa6vNVfNzuCtjk8I150vLmILr0HV1Q9fFn2vHdXxzy3adq7WLCGu6lt9rwg5ky8kWL9O8EcQrwXDjy8xAVcPXBc3r0TExE80cJou7ugPLrsK447blC/u9v33bxw/pq8cWSIvWcL2TvpF2c8haWBupCLCj0pSR+7iPGcOoDTST0AR3s9SiQKPMFcvz2n6Xq8hJKxvR8BNDtmYPA8AouaPPIrfjuV0Wi8jRNnOtzijDuF/h68h4HcvB0eoLvwofC85PrJO72+i7ylEaw8n8PgvO5CKrzQ2GS8lS9tu3T09T0imys8Q0pjPHnEzzz7RKS8+KoRvDCdljr7nf07n0EjvFwEfbwTSd68vWntPHWcXz0V/r88QBpjvLOAH7unbDe8tBFOu+8A0ryxnAY8tVBrPLlD2b1Bqho7GoPsPM5KI7x9QUA7Ux8svJb0fDxiuMY8jqKDu+VX2TtV1wE83tAyvQGIsTtWnBa8X88dODR1uDyKTTc9NygAPSg7dr0mXIC8jqKKux+khr1DLFA8x7ubu2YrUTzLCRY9NGrcvGHU5DxYQeU8DPSWusOhgrynnFU8R54ru1dZabxHbI+7JEB8O+szJjyKVbQ672u0PE92mb1M78o8+4awO0kFnzvjda272HDcvIkDGb0nKIs8836Eu9WoYzy3P6i8kfgfvMQsMLxoAw67AE18O7Jg3L0pR948pgDJPC9JtrvLALK8mh9KOxCw2j0AAV88rL3aPI/FJbyiINA9B5ElvMJpNDzgusK8rjU/PILM0buwh1C9QADEvIAbL7uJ0v+8VmbAO6G5Xju2SZ68sl/CPGMngDzpjbI8MKY8vMpw6707qdE8O3RgPXrnCLtqLf69ai2DPShjSD1buuG8sTcEPI9dmj0LbKI7MuwMvLxmzLyR7kY9ZkALvTkiuDywsQM8SRC/PIpFNj0HGh+8qT/kvBMA9zyTnd88reM3PTVzarmD4eq7AfbLvMIqh7yE7xo83n0KPY27d71za408CChMPSgVCL0CPau7lF6lvPse8DwiL1U8JgfCvGgJ8Lo3tPC7RzdDvL/KMzzknLC8654QvFLiKLyzqo07mYPUO5ezWw=="
+ "[card]\nname: amber bright cobalt" "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"
+ "[card]\nname: amber co" "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"
+ "[card]\nname: amber cobalt" "vUYRPTurQ3S8GMh1vPF/KbycTVW84fA5PFGWnjyL1yo88LhtvIMUNj0553C7lhAFPSDZezzL4dA8Um0jPTYu/71f6q07sVTTvW61D7qlqZq+GTglPbnWg71+ppM9U2N7vTRsa70Q7CM7Njv0PWIr+r0BaYS8DbFhvN2fAr1ZGdu8jOzaO6klc707wZq7pHx3u5JqSz2nnSG+HIjoPMvV/r05yQU9CtRaPPVovzwwxOE9BCYtvQDQTb06Ae+9VQJJPR43lr1Wx9k87JCXPQVNBrt2NbU7dtI8vAyMX725VbG870n5vKpA5z2uaCS8vxdaPYH9Fzsf9so8B5Omus0a5L2b5/4855n5PVWlj7lk/KC8ebTFvLB8krynMo48uqM6vXCRCjzqzWC9hzD9vTTy2Lwy+sk9LRJ2PSsUXzzSfvA96IuGu8ZoFjvgz4M78hWSPQ44nTzcRTm9b11sPTvJITznw2I9Te0sPHTmjr0o2TY8o8PSvKd4rLzTYYg8Jzt7vYGtQjyJMkw82QekPWLqcLwqDDQ9idbRPRBoXjzFL5M8U2JVvYUS4zzQruk8xnZzPJoFnb2O2Fs9h5r2PA4BfD1sBzA87QY2PGTl0Dzg2Jk8PVHtPaT/+ry13b48AetivRaQCrt9w3M8uma1vVHpk71Fo2E7yOdLvV1BiTzCAxu7sGxSPLGuDz1zKfu8/U18PCky9r01zFq9MuJqPW8wJbzRg2g7w8FnvFa4Ob0BrTK8faOmPD+vaDwazua9HOuOPGii9D2PO9w9Y84oPGUUsrx1Mq+9AJzRO1MGB70QcxO86nrlvVEMOTxf9Je8FiSqPB1ABr2gO2K9NSqcPKFDvbxKAT68rA2OPY1Scr2Xftm8CUPSvI9UMzu/viM8zxxtPaXrlrw1ek68lsgKPY1VmzuydJi8pr4jvHarOD1Xj8U8exbrvVJXBLxcZHK8ZEoyu3LeWrzx1/c6PHqCvU+gErzRG9M7shusPVbi8DzPnRq9XIBePSLpub0XHqo8oBBwvIz0bbyFU/883IdLPWaPBbyZT3u8qjTUvSkv9LtVJNG89xEGvcTdGjx2PC+8+xsZPaMToTuJS3W7v9b6PYnUhTwJUm69MDTUvbE9UTy5t3S8XCqGPV3DdL0SGHs8VIpyvBsS+T0JQ3+9Ffp7vIh7yDzf1jw846QXvOrpND3GJAG68nAQO+L8G7vCqfI9vAAOu1V7RjzBTGK9hiHWvQPgUL0Ut/89to3fvU1txzwmzQU9I89Vu6N+D7zBO1K9lztmvJnoLL0lNcK8eS1UPSk3lr0Hm449HiYEPNk9Tzm1tku7gSWBvQ5kt70VMT29Ou7QPNRFQzxqTke8fZIWPZje3rw+nRM8icV8vDmrmTx13hs9JaC1vS/PeDyFXuE9I0pbPJ2wZ7vdZSA7vb5IPUnuBjw09Py87TFku7JTP7p3xIm8jsdXvC8eWzzE0Yi8JtZpvL3pRbyFUuo9UFCTPHCKfj0Wmzc88UAGPCRx9zzZixk9CuDyvOD1DzyaSKO8EQZWOybFCbzDZAm8uyvWu5RRtj0a1Vk9JgLkPH/guDxNS1I8GRuEOhfY/juZt7k9Fo/WvJmjQjvTi2o9FMhHvFtneDzEQg2868YpPKo68TrwAiG8SXhAPNQS0L1uGaG8uGgMvS1wBrvo4bo8aynVPIxiM7x/H3i9Ny3MvVxCgz2ibdM858AlPKX1orz3Hcm9VkQQvFLsgTq3E3+7rVcvvAASvbxbFnK8yZI5u4UNMLzmDnw7Bs1QvBaGoLsb1ee8um51vBgluTyN1F67ip41PKymmDvpR3y6mciNPQMCgjy5LG49MClkvMvcbjzjbj28zdmZPJ/QgbwvPJm9E1cUvDmpqD0KUgg8KI4wvCCIBz0Wewe8sqw4vDpC4b0Pqtq8vFlru1EUOz045qK7l23rO1dG07yH+aM8nY0dOwSPqz1EpKg9M2QtPJHmC7wuDhY8Ng6lO+AsrDxRIY68R6W7PEmj8bwOu188rFM5vF+KE7wNgvM8k5YDPLWlGjxy2ra7+k11vMI8dTytu6Q9ENShPGLARL05e+a8wVeIPMdK4zzRxis9BRJMvMoABbxvbYM7GP0duynX5L01pgY8WLtbvB5XNb0efLM8x4NVPOLphDrHk9A8z5d8vNQFBTptKZ09NfG/PU6Bir0hSJq89qNtPMBJNTzQ9O27IcAWvCsyfT2OjjI8rLzHOqvShby8ouC8JEljPQOzEDytFau9hwG3vQpjprx6B/K7bE8tO4fFtryU00I8UuVZPPcOpruMn9U7kJLIPNqjRryOR9I8136OvOgaLT0IcUu9mhkuvNinijz+6RE8vV+UvPadFbuT65S9kGHnvKFiYjzQ9Ju8NEuWPIM3U7zuxtc8S07DOhai1T0EoUg848uivLD8WbyB6Yq9RmWrPBsEQryEo2G83JHgPD5IpTyBoNm9U2ZCPDq1hrmkT468ofa9u9NzMTurFo48Y6q6PIb4wzzPzsY80GpYPSLstDzhc4C7NO2NO9jtFb0OjMA8wBeMu9chRjzUADO6m3tpvO/hVryGx8Q8eiZwu8mTnzrDXr08pOFJvGpxgzzP2iS8KU/svRgCXj1BT7I7PNOuPKQVaTwm4+O88/PAO4T1Pzypmaw9gq0vvJF7Yz2xeJK7mBUPvUfMqbuCv869C9zQPI2rXDxvdpA8PgBvPF7t/junTzI85GfvvSrvjru101i7uuRzPbvYJ7xUkJy8xDc8PTqMIbwD++672a8DOhrYCbyO2VO8Ko7pPAz/MDuaUNm9MHvsvL6H4jzJ4QG7iNp2PI1Mxzws0ee7prFQuz+Yyjyi6t0835L1OhakFjyj6A29L5CAuxUpK7tFT+O8wYGcvShFELv8sYU8uSGlO8zr4LxEeOi8029sPSSkKbxOZM89S35YvBdszzxUC9Q9FBiRvRcs3rwkv7E7r9rdOrhZb7ztlde8cre1vOCJQDv3bDe7iWahvN2RhT2rgLa4D1/gu+JKLbqHhS28p6mwvGwjurzu4uE8UvGtO+oJi7uxy9+7V7WUu648LLqkB2+8rqrtPKt5bTxWi6W9JafyvSDDTrydIhY8tt1avTzcGLuw/QU8JuprvR5/3L0JYss7fmnBuzJQr70OZPK6WIXwvTksn7waKac7OaGLPNKYvT0drd08fz1guwoBLjzsgn68AJ9YPGOhhDzK0s86wOXjOeHamTwqDuK8VP1LPBnLWjx6W8A7Z+BLPUlKYzxbLQO8E4psvNjakjvDSoC7joJdvQyONzrp10M8ofW3O9MmqTz2qJS7zbNNvW+hIzwqhuQ9gvJWPMlJ6jx1UBY9KbrzvITOULy4aaC84qacu2MpBD1IShO8tbL0u+ualz0P5C46siLwvGJKXLy4nYq9HrY1PJC2mDzwoMK9PGe7O8DOJD0JBXu87VR4PNSLpD0M9qg8v9N+vJC24b1L1x29RLdMvNCFLTwCNg+8FVJMupGSMb0M+PK8sZ3EPEXJ1bwkpqm8BlWjPUmaTL1Ig9o8n0DkPYYHgLy5bW+6n+jfvIsh3zvV9RG88ZA6vRHvebw9ydU9C9FjvBxj8jx4yVq6gXhvPKoTb7zMc8+8wEsJPKFaFD2OuW48oMf2vZbrXDuciK+7EdJZvLsl371HthI770lRvJ7ci7zGRhC9TdVPvCC+I7wYs9K8yuOcvLjP+T2tJ+K8rbjcPMUl5rutqze8YNOCPI1LwbzsnEO9T1WfvUwgWbvyIVw6tI2XPAy1VDy9rcG8m1VwvK72rT0n16M9P2hFPIWNC7yBAam9jKX0PDc6Nz1GWUs89WAfPPW46bwZIlG9FSNaPMgAJTvgKOo8mbLLu6ngkrwgfOK9czsMvJaexDzyh/49FDsqOv+eND0M3ke7OCplPQL59jxUS189LSOsvbdS3T1AJNi8o16oPBBCbby/4P08eJDWO7te0zy42HU8rUjhvVt327yogC09YyDdvMNlBzxhi4k8GEL1vNxk2rywNUq84w2lPFzpJ72oKB06nShAPI+/JL0R1/i8RXKRPHbN5LztVfM9KiK/u4D3HrzoQxq9FtwmvT/VITpBnyE7/N+ZPNYNrr0SVVK8moOjPIBIbbuUO/U7k8RtPUEtjbyRCaS875r/u8ufObwsg+080HY3vFLuCDzMjgO73zlZPKK28bzx/kE8sGy/vBcDWr0KFm28FG5yvIh/e7yCqyu9ZjYbPHMSSDwDqYu8Cj3Au0fr5jzelDS71tZtvP8sBjwq5e475+z+vUs3/zxJ6AM9FQhKO+eBxTtwXcm7dTNHPP1+pLvOkXg9jDxdvN73DzwMCQK7xuCDPYqTgjxE2BY8bLQ6PJqQOb1g7tu9QWGIvKMXbDxfqEw8xRJhu9ckFbzcSQQ9irR3vFIlYT0oGH+7z5qUvEEkBrraTOK860vhPCUDk7ynCI+87L+tPT62P70YsZg71SpfPGF5rzyKlG08EmAuO4x42bn9qgO88h9uvNeG3zq4pOU7v7+3u4yPPj0KEH67zH5BPDhMvj0EEVM9AfOKPNywOD3Apv+8T4JDvNbvojw1xXW7kJiIPICQLrv0se28nk2bO6RHgLu9+ii7nUuwu7mfqLtwJYC8oxm6PDzaTLyWLrA8EPe6vROQAbz89928UpfSvLKBJDzoIes4RWCJO+FlODzdSEe8q5dAORX/Dzv7OdA7s9cIvCWChztNUTq8mNODPLBWDT0oC/08HIiPvIHyBzvlGKG9Cv6wvNZnnbzXxRs8xpY2PPC3G71ZAag79UKgPA3kUzvEwYe7PppSuyymzD0OvQk8ivv0vJR3SLrR2Vs8f8uDvKUqrrtF/Yu8HJ4jPHJQST0aVe48yQZiPTZnc7zh2R68qnd/urukOLy6Gu08vZYiPNNu+DynbWI9Px4RvMDK0Dyg/iM8UUoZO46y4ruyZow8kPdPvMgvKLyrfeW8K8MrPGsT/TzJvwm7TOYpPO26S71eDrM8+o/DvIx8W7uyxZu6kyv/OpLwg70IHjs8rX+RO3okNTyrhxe8pbnqvI9p/LwHW967M+LWO24TF70TAlU8g3yuPDnv0juRAgC8o5SaOws/lzu6PxI8kNuWPCrrpLxbKsU8xSONvQieODwkUY68u082PLhJPLsrwXK9rHNxvF05NrxBX7e9Dk0nuqj28bwPqyO8rjI/PDuPGTy0Ecs815jWvJVHPr0jqb070evePVgu3DxWhgG9V0/DPTHCET1tltq845uPPMBcZz04n9u8XJ3DvGDor7xCd3w9d+7mvQj2nTzpYUQ8SF6jPETuczzHfGO8nzsNO1fKEzyVP848KQgvPS7n9Tumd6+7sULcvA61/7yELvE82zQePaWgd71jM748R+Q0PRKN/7zsRM87j/yRvKh0pTwreec86qPxvL9KEDsAT+O7R5dPvNvyZzzoZvC9Bm09OyCoQ7z4aeQ7p6W4PLBIgA=="
+ "[card]\nname: amber corgi" "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"
+ "[card]\nname: amber macobalt" "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"
+ "[card]\nname: amber not cobalt" "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"
+ "[card]\nname: amber or cobalt" "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"
+ "[card]\nname: amber taco" "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"
+ "[card]\nname: and" "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"
+ "[card]\nname: barfoo" "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"
+ "[card]\nname: cats" "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"
+ "[card]\nname: cats dogs" "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"
+ "[card]\nname: chatty" "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"
+ "[card]\nname: cherub" "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"
+ "[card]\nname: clients" "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"
+ "[card]\nname: co amber" "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"
+ "[card]\nname: coat" "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"
+ "[card]\nname: cobalt" "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"
+ "[card]\nname: cobalt amber" "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"
+ "[card]\nname: cobalt and amber" "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"
+ "[card]\nname: corgi" "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"
+ "[card]\nname: customers" "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"
+ "[card]\nname: dogs" "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"
+ "[card]\nname: foo bar" "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"
+ "[card]\nname: foo%bar" "PM68kLzXka29YwYlvElEur0eZMq9uGbIPNRVWTyoE0i9AjjHvMsBPzuSD0A78B0yPZCJZz0NNzi8eegoPOP7nL1MUYK9O42AOyq4Q7wN2Eq9pEf+PZbP0L2mQ/w9QgCGPGwOFzyK46s9J0g/O1WyIbxawJk8nKu4O4p/1r12mva9mLWJvStT3L0N+4K7wAYnO0NVYDxCan6+GjqcPAow8b3Sdk09wJzvO8mBubu6OSu8e9n7vH/oqbzdmwC9GM3VvIIuTLz2PyQ9BrzJPRg0LTyCdhu9MlWiO8TAlr0HKz271paTPOzm3T1vNVm9EBkGPSsCeTy7Wjy8ih1MvH6YL72y1G274BWePNkRKD0kOZo7iqoQPNnNADzCCVa7nAOBu9wKEbwI+629kVqAvUoaNDzFl247vEYhvQ8pEboA9tk+ClolPE4yMD1RbKC8hmmyPBgnLT2CDxi8okPGPVkC4z0qKWI8ji0QPUjkUL0pDYk9OZMmvLTmkr1L7sk9fBkzvc5bvzy4ZoM7vKDVPIEtfb0ECsc9i11KPZ7kzrxKMWS9mFXQvUk+aLy1jUE8jodvPJyOFLx3o0o9dEHJPJyqMj04j+U8lbCqPSBwSTtDrPW7VaIoPLA9eLx5hYK88x3EvL6L7rzpveE9Ha+PvRApd7yyHtO86uTLu7swLD0wNKy8fEtdPM6V4D1lAck9ZE72PPmt7Dv/gNS9ggT9PPi8jj1Ck1Y9N0ArvRYHYb2M8RC8pTl8PV/3j7ykyCa8ikzZPH857Dv+09c7nXWCPJqtabxB0W+85cxFvWy1Ur0AiTE9XoGUvUQv9D0LyPS8O5qpPIBm1jv6HJG9BTc3vMpuRT2BvLq8SOd0PV3IKbzaRXk810f8PRyINLxjHL29jiOuudby2L1TYBK8d54WvQVw9z1Hiiq8yv/ivFq2/z1QPHc8tHHMu/DaMj2NABi8t0UauxgPf7zsA+E7zrWTvKr0BbzHdIy9Jws1PLpKrDzBFcq9sqyNvLjuTr2Mgug9an76vXI/LzwoP2o8vU/gOk8vWLud2DO7tkjAvQmptLjjzja9W9OJvcjNTDxiqHi9iGiYPYsCpz0Su6m9J0HCPTNlyjxO5rq88hBOvQxKI7zyJIq9C1x4vOV+mLy6T1e775eVPSlE9jwL2hS8JrmWvLIEcD2fjgI87UpDvQjtUT3iMdQ8KooWvSSCqLxmhTA9qpxQvVWIGzwZqD29m6JbvZpeVr2E7ae8dPQDvVjDhD2KsnE8MeqLPMllILoeRZq89WbTvM/Hi7wFlUg9Fl+uPC6pyr2wkbM8iagdu5azKLy7uiw9Lc1lu91B/Ly2NBS9cU+qPY10iTuS51c82yt7u78SGrxkkKs8jpYGPBbRkTrZi5E7dT/rvRkUAry7ORI8JJf/O6XpeTyJrVi8Q4r1PYjmpzwA2Q083PaHPEhFuToHaXE8lc4fPNIxVjyO/qM8MvhUvWb707y5iGQ9eFvRumTrjz1WK949JehcPQ31Zjzhzs08UNtbvI9Lhjw1zbI8rHVYPRVfuL0thha8g30dPNycCjzNFj88ZEdfvQ5Qvbq5Obw9ZLznOl8Gxj0BHDs8oiXTvQKyBTwxbK08xGqxvGYvS7vQ9Lc7+XF6PO/DqzqJAlO8fLhoPU3waL0ljnK7eCKgvTqUobxlJDy7gi9cu4OcNDw4gqa9d3YMvER+yj2qc+g7QeRFO/q95Ly6nN27yV+putT3dbyCGlg9C2SYvQyEKrtECrS9CPHzPBmJbrynw/c7/6gVvIWdHzvXMEQ8u3YNPQt5ojyNxZ48b7PVPEc0Dj0SOBA70WFbPLhR8TywNAc71Pxru7kwXjyYIvy67bNlPJ6xKzx8Kii88c9Wu96OjT0t2Ba76vHmvNW4QbxLZ+K8zXdLvGgFpbtcG2I6MXzsOkhDgD0EG3+8y9+yO/LKWb0KMUM9Dax1vD46UT1pZg67wa1CPF5ylLy/BVi8PQmwu6fFOT0dppQ8Fu2RvTlRRLzxhBo8FSkbu4O1dDyYMEo8GVJ+O7elFrvYD/q8UhyKvIRKFT1Kom89QvwIOrNspb0+u1i7jKMyPSwvgTxWFSq8BnH/vQauKbzQtJO7Ayg9PF4vBTx8SHk8eIjWu7iv47z/wcw8VIApO1RWYLs+wz88JYoZvJyf771VifU9WUGRPQM2670J0ji89Kq9PKkMYTzH4vG8bTRBvPgotD2GSR08GiTGOue7z7v/Js+8oXKXPQvkk7xFfc08BF8WvG/ByTu3hI88TCGavUSOtryoaGC6WEbnO6vY/Dwz0sW7yLS0PP6CPrv8zH09EymOvKdRvzy4/xa9ENJ/vQzvRDyVc/i8PEkzvT5uKryjxSO9hTP5PKwH+Dx4j+o692rOPEInJ71pY7k8neO8vEp6arwbn6E7YAAjvQdCj71K5Pm8X72jvRw0JrzptZW8Q1FIPQyTYTukWDm71vosPWMnkLsN9EO8gipzPJVSNzxewFC7IKIjO+oVnDxdbUm9B5QbPNmO6T0D89E8zWjDvEXf1L1Lr3Q9CAarPLoJpbzYd1889E7svXH7KzxEHZ47m4rrPSvBDLyJ1FU81yOTO53NlbxkZTU7xWfvvKeYTz1JK3a3hvCCvQSvALy7G0y7HTFdvVocMz1rpkM8XlmSO6Rzwj2Owsq7xJgTvSRmIzwqM6a89D68u41tRzxYb2s8WINEPFuv+TwyueS62BPKvNBHSb0ShX28MZ+IPYv/XbywA+a7hVupPE5nT7yzinu9A5l0vBFFcTyvbZS7zZZPPK/ZSTwHoqq9D3kLPJblXLseU7C88KdavKXg1rrGomE7NmYiO+kEgry1Ldm6vgaHuw0JrTyu0qK8OB8YPA5f9Lz0l3G8rdsjvWjtVDzui9W8ApidPKi/UTy3UsW8hUU9PE9qSbtjz6U8dPbnumNz4zzbJQW8BEnKPJlN2r0PVfS8DOgCPBYjeb047q+9DDE4vCmH5TvQHg+8wilsvNU3Jj11E4i8ME6wvNmEpDy1CDA8blBnvRq4qr0q0+y84i4gPASUhTpq6bU9FZ8eu8Q2UbwG2MG9D9pePP3eCj0SUqw8fqk1vKLvQbyCfMM9H/IfvKGUGj0ZWpw8fdKPO51YQr2KMXK8BTLCvQMjnLy6/8w7t3sZO3WKurx9S1a7XT7uPIM2oD3B1PC712bUvCToFjwyUH07iHKavB+J/T0uBrA80lIxPNEpqjzYhlS9KXhrvMVvaj0v8na7qejnPU9bvDxShfi8mPFZPK0+yL2HGLm7tYB2vMzJ+bqXLZ07/krMO9+Cczy7dZA9OHD9vQt+/Ly6OsY8/kBjPMfx9DvqJcA9tQmfu0AdCTxktD68skHvPQUhnj1agKy9XD3gvBZslryuanC8O5rVPAGUwbzH4DG7JegGPEv5A7vcg3G9K1hjPIk8Sj0OKTI8iFocPH9bTjzg1qU8NJhWvKPHSL1TwSe8RZnlPINiP7vSHb29Cq0GvGEjMDg9BK670dKovF8DiL0SqF48InNnPLalLr0oG009B9nzPUDWtzxKvpK808yqvKKopr0ompe8cIaHvAhOOrvlgNU9nd/9vLaBajyYl9O8JCg5PHQo5T0DbCU8baNFvBTFLjvx8cK7s6oVvUz6SjzPdQq8JcOjvTf6r7zvcEY7T/YgvHqjy7w9gj+8kWZRPILGNr0OKu28/8X7vIU+Lz1gBuA8zaUWPRiBa72DoDm9JfSOPVGdYjwsT9e9hn6tO+pJTLx4Aym7uVzBujzXfD0ZIzy8d0gPvLDFBTzBQ+Y8ydTRPOl8gTw/E2w7+KTSPTvdnDzHBoY8R8dfPHslOTw25268rvOjPIzthT0GfRo9Znv+O28Kh7yezOe8WUWDvAEjVDuOiVA7ruoxPHCdsTvYtTg8uEvou7xUAjxStBQ9YPw+vRpe/D187du8Qp0hPGAbBjqjh7Y89/w4ug9afjzw27E9EEWWvYWgh70lnCo8eA+AvNgkPLwc1ke5nH0rvDphvLw3+r+9Ixz/PTqBh72Frhw8m8dAu5vdk7x8Inw7dua9ud+q0jtMPTw9gqryO+gZ+r0w6/K8pOlDvC2tuzyKtTw8VxQBPMPHxb06xIY7M0xeudu0i7y3Ueo6yjFfPUOefbwrgzU8pPVTvMrCjLwM/8w9DalVvIkDnTv+yeM8npwjvEZh77roTPk8weJEvG3MMrzjqFS7hWNau4KdeTlgVXK9LRYNPSNAHTtSZWi8mYfIvKiTELuiLje88Ui/u97k3bwFqCw8gJWGvQ/A67ue4og9B7dXuYLvqLzc6tq8b5oxPIoNR7yFO7A8NLRevH3VTbxeuO68Xy2xPZKXUryX/LW8e/w9OXWPSbmRJdy9Hvt3vQauJDyGhjk9JBlbvQa4kbwTq+U9NR8ZvHJdVD2FKv47laLVutZ1oTyMHCW8FbnKPCela7wsDna8wUyoO9JsVbzNr4M8Az5wvEeF5zz3eBM9iI5HvHgnF7sJdQe8XtW5vNYmdTyQBZs8OuqyPDyCNbvNo1q6j6ruvUHb+Dw6Qd88ujWuPRlm2TzfQn28wl5KPQcIkzzXV6g8+hsePKhqA7tFLSS8Nn9aPNp1l7v3k3S75qFGOa6Rwztsgf4710WhPWPP3L0Xa2Q9BWP9vKJ0pLzcTru6YUktOZPFjzxZlBe887cpvJwE+zlgahE7AgYhPAxdjzwYr5o8zkmPvMbtSzzjcwA8JgOfO9NFlz1Dd7c8uSeWPB8P3Dy8Hd29apy6vOMUF7zj7Nk9ETitPMNro71Asyw7lTKdu49ZvTyXqlu9c8pqvIGM6j0+bM88eBiQu5XNuzyODg08w1eWvQpdbrwHbcq8eOesuPcadrz1dRq8uUpXPNeZoDwlD4w8x3oMvJoyKbuiZFM8zd3RPJ9hhTwTsu48DjRgvC0VdDwOyta7vAFHOXg8GTx5qBM83BpgvI28DrzSjMA7CLnKPCyekz2fyms8rfHevFgwxL2e+jw8cU30vEHc7zxAg289MXD8vN+dMryvMiI8Lil+uv1uWz1e6Tw8JuZzvRUgsbzcGfe8P2N7OtR90Lv3swQ9CeF0uihHwrwP33+8ktqruk2OL7xqi5Q8sh8SvCkmJju+ooC7gLy1vLPTojwidkU8oh6kvWEnfDwgzWy71yrKvANqqjyQD0s8iA53PBnmrDz44Lm8CS6uvOChNz0aQzI82IpbOzUxtryO/3k86yPpPKU6ujvINbq9ABCyPNz0zTxIuEW9ABOuPNN7tDyTJ3u9KgmmPIJVcD0h2FU8rwi1vUfjp7v/pHY8p33+vH5j/DykOtO9EbUvPQX/gz0Ocz+8vP19u6C6XzzBTyM8dVMdPDjmiLwhEA+8l9DSPRM0NzsJAqA9KxLoPSMVA71eM0w83Yo7vWWCjLxYA3E87eaMPJB5fbyYRU46rFIBvH6b8DwajkO9MJlLPJmNa7sR+v48neJcPDbiXQ=="
+ "[card]\nname: foo-bar" "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"
+ "[card]\nname: foobar" "PMo8JrydN129jBc+vACOLr0NVCK9XdaRPJPHWz2Dq7S9HoFNvUU3JzyhN2i9BIf8PV2vRzwpU1q89eVTPJcV9rzrtIi9IsIiO9FBpLym1LC9kQPVPTEjTL2Cf1U8yuwbPQCIfzxhtt49cNl1uwi5xrv+Ave5SI+LvM1h0b2vk+C9keCDvL/1Jb2Id9Y8GCUVvPeGRzwnZ4a+IHIHvCvCpL3gBIs9vTPBO6iG8zxJ0lC9BI1KvR9Jc70tPye9Xq8DvMhLWb1wuHE9DbBSPGzQSjyVE9688S3rvFw13byVHmu9DBHrO5rTHzzGz+C8lAlQPU5V9Tzg0rS8eS8+vSrSwb3cF148jfvjPXRnRzvrK7e56P+pPGkO3rrTEoS8+YYJO8lV+D0PC6W9HBIxvaH5LT0LFFs8Y/JmvRMNvbyLwMA98IiqPFmt+j0kmIa8GghivIvVTD1wZJO7H4cGPWFjSz2Ul/89JM9SPJFTpbzzZuk9LCu5vMVDE71kCl09W2XQvWrUsLwC9Vu8Gt99O3b58by42KY9itPOPVnAPryL1We9jGzbvOaLyDwpbJE60UIoPCb41r0XKwM9M5X6uxvNzTy0ksY9GS7TPTGqWroDZ50838hJPQX5kbqxI+O8QiqKvJrkZrype548xYMFvVESYrymxK69EQxLu5+tXjxPn7m84TSAPDaRLzyy3Lg9OkMdPONvurskixS9W6o7ueiDOT0eXJE9BFw0vaFXsr1ux4e9DW3XPUgrc7yc2XA8B+2rPNx7Dzrl34E890eXPU8n17yLh5+9PQqGvaeUv7y/cgs9IScivQfoWrwlNvi8FT9XPOWfKrsXOem9IvxTvUJbaDxsEqW8N1ZFPcZeE7zABPu8KqMWPZgTuLyWVt29VDODu7qhfrvwZcO8oJWLvIsKET09vdG9UEbxO/fj5z2aHt28gOu/vSdfkT2OBES8mTzAO82pfL1bE1W847EFu6TYgbzDpxO9MQvAPQYIzzyIOiu9ffSYvJ9iKr21w209LzY4vYsqGzu7i+g7lRF6PI86tbx8kPK8tjzhvVCFf7o/2rm9M8rYvdjkwTyOfOu9NKZQPX1xRTwGBtm8gzJRPAWmAr0D0kA7kGwyvSMfmLyQjs+9hJ01vGz677zcPzM8zcwQPQtCPzyDjZe84oQdvMR9lT1wyXk83Oq1vLSxHD3QlMg82vChvWzyn7yilOk9jRDJvSC61jwmB++9oIiivbOtC72fFqo6sMpovZYnKD2h7EO8hBodPC3IBLr8v8C85s8zvKLbrDyPnTI8Y/9SO7mSl72IINE8LjZ3PJxhI7z+PQw9M3P7u6JZL7yb29i9jawFPZPZbjzT0jE7YIh6umL4ZLy/6Gw8dLKpPRYsfbwWE049DjjRvMSODrzleqg8RD77PE/URjvuj4U7ii+QPWu5qLuy/ZQ7EDgxPIMXdryi8O88l6oCPOf0zDyQabA8pqyLvQAV2rxxcx49FQvtO9g8iD0wm6Y7fOPkPSSSfj1ELfw8pImRvQsP0TvXSRA9NqPSPSGmKb0wEom8Zjj3PK7elDznHUg89/JSvHGDsTzLOHU8+7EHOjzmCDzXthM8AyqkvNgiwzuPHSo8zVOhuuOc3bwZox88bQsAPWUkuTw8p9i8f752PO5vpb1vZXu8c4s3vPi5Xzumlpe7pRjPPKCIQDwOAN69R9KRO9ravj22WV08xSMpPLqabrwnQPM8JzOiO7YiwLxqhm89ALgmvCDJqrtXQUK80TKaPCTVsbzU7wA8MpE7Ox4+/DuXJUM9ELNAPLRfsD0OHYU8ySzPPJsA1z0lYQ88rjc0PCUVeT1fhzc8Nv6UvJarvrwc5Mq8VjfWOy4j4TwfFcC8iCr8uyloQDzqDSk7l1EtvBezYTypzw+9ImF1vF9+RLwPO4i8jw4kPHydgTqZtY+8O/zmPBYeDbz5TrY86dwQvEgv1j0mSNw8qs4yO2XWErxBihu8z23Auy9VYz0+ecw8bEMcvSxRs7yly488mf63Ovd4BjuTVB28drqBu95Wt7xb/sm8hXPAvJOv/T0pUjY9a6/YPIy/m70GlbC8LjeWPSBLlbr3IG67Q67IvP/IRr0sHuW8xMllPQcppz0TSpo7uUAVu5Fg7bypGwg8bafFOt3QezxcVr88j1eEvEdp3LzLdpM9XOadPUfRbb0Cnh+8xEnIPRHmnzzO7q28QKaTvL4SYD2S8646Ozetuo/s9LwUWJa8nbNsPRI7Azzg4V87EM02vLgKBLqCYVI87TybvR1PDLzD57482ga4PSpb67lGe7+8KMBpPKFORjyNTxk8BFDavSmh2T0yK/a9DFLOu7QB9Tyismq7QaDvvLYVobxe7769nm2VPGu26Dz4+yS8CPxrPCbp8b1PBFI9OsTQuxkBPrxWJM88t+lKvRk7LL0BTUO8WFIHvRF5xLwMs767uafhPHzIDjyIQOu8jqOuPX1i+Tx2/mm8s+vbPENrdjyr5628MOqaPI3HYj0jMwy8opflO+1cazuk/vs8VFMTvMsAA70dFHI9FO6ePONHLLzEcZM8/B9MvR4pLrpMY/k8nkc8PUzYObxk9EM82n66O+cYprxHjFE7TE7uvKTIqT1LtK47x1T5vQDKYbwxB0U8JlE0vXKUVj1IktQ8hOZquizVOj2Kkk+7b+XUvQ4+u7skoVm9KGTZPEaCJD0gWiI5tzpbOurTu7nRPGQ8+MgivImxBLzeg9K8pyHIPYePsbq/4NO7DrY0PQmY8Lz0Uf+9IECPu6pEyDz6DCi7UiDsu6iOYjwg6zy87J0DPAnvBzxB9YC9BSr1vWpmRDxA9Wk8dCOPPNkxBrzAsqi7uBUtPIaQlTzpoWO8iFfSPCXpDLxZx6i8rh3lvTjnVzzWjy66p1jOPDBHqTzWtIi8xsPUO9Kw4LwprU89Jptwukakwj0DMkM8Cwl5PIwYybzSzga5xhIkPKv0m7z8qbu9UyUtvHmk37wWMYm80y1bvKOdbD1tanK8EVbSvTPvyjzrQGE8g6tPvURXmLzo9Hm9j8aNOzv8OD0Eo9Q9OlBAvBDKp7yDvfO812BfunkgdjzA4k+711yLvGhyRLxWIOQ867KbvCEE1jzLo9w813B+PAevqb0gw1m8KnPrvPBpxL0xGUG7D57gvFbh7Lxu9q07s84cPE5Usj23l6C8qDdNup3sXjzVDOY7ul5rvCcpAj0ChJU8xVf7PNKknj070Uy9ds+CvRs4DDyrENC8Wn7NPYKjAT0BUVW8xQInPCUd1L0Xccc8owFqvLJQHLt+NGk836MPPCKT3bv7KP09c2uQvQY8O7zzb+I85ri6PQo0iDyFBG89jKA+u/t/BTwBxRW9BI3aPDw95j0CLwC9K6VxvArbFjqurVE8lXZEu9v5yLw/J5S8wwCkOwjaEjxjDGi9bG3nPQBPGDzATZU70cMnvAoujj0QcjQ8fbBzvAFALL0/RlW7O6G5PQQhdDwgGvq9D9nOvCLowrku3jq8yiigOkAB4ry1s/08iml3PSWIkbzk6hE9IwvVPSdi/ryxPPa5E97gOe8d0L0Y1vC8ftl4PC6Bn7zLYoE9XnQnu7h92jzCJQy5orjrPFTEUTwh2N86ixaPPEt9Zjxe/G27P8D9vWy0ZzxIgZu8yU99vSw8Ibz3I7u6ymO4vI93ArvbOhy9Lqe2Oy4TfrzPAsW9EPtiuxWBAT2WGy49BCaTPKjuDr0/4ve81Py8PSGwYzxuAvq9aYrKPAm6a7z2OaI7raEdPA3STjztlrS85GR+vFTKUD073X082j7XPIsXXTyP6NE8VoxPPMifFT0U24c87r+0PMG9EDu9rta8q/eVPRJQADuptyI9kPPFO5EnULsgqW27lGLNu+dm9TzEfIY8PqiEPNgiGrvXvtm74N8lOtAtDrvO9co9eTkAvNXbtD1FwUy8ynfVPAYtOLu23qQ9GVXIvJfBlzze9WU8zRcAvXRMprr6Rkw8INgOvNxFO7yEVxk8pctevAfWtbxAdqa8qLnAPN5EJr146cQ8gfPEOcK6ub0Cosg8RwXRuhRujLxCQfY9gNbxO5PeUb0xG2q9B8EfvDQOCDxkw/I8uwUDPJGiS70qMro8e3K+O73bW7zajcU73SgmPVXsNrzz0oQ8xh1evOemGjuKfxM89A6AvJAopTzGCZM8RLgPvDQQHDwsPFM7GgVnvR1hxrzZ6kO8QgJhPICC3zwXi5a9NhpvPUYgtbuZhJK8NdmVvJOfKLyvEGy818IdvQZnwrx/Ajw8vtRivHYrOzynTz89BYtQupI4DLy6I8S78M33PKfR6LjreQ46v/GLvCzwP7zMa/i82J4RPYydgTua20y8472lvEdwcDwoIre9Ak0ZvOXTybxXQzQ9EKeHOyTEELzKV4k9OhtCvLsqOD2lHGA8BG2fuo7cYTx19jS7P9W6u5EVoLw4mNa84m4tPEC0hb0kmxm6j1AkvMUg9Dzmqdk9nGNxvQl4BDsXcOY8Dc2DvIBk2jyaxxC7tDQUu1h1WjqRWEq8TppuvL1PUzsSRpg9LMKrPOzinD0Sug+830WoOdiYoz0cwDE9DGbAPOd3xzn1sKs8J2vvPRRNWjs26Le796vKPDCoBTtXRP+72zj+PUbp7L0oF1o9BmPCvGTeBb0O0VA7Ga1rOuagEzxkrYi8nkjnvNEk2rufgOW77qBmPICxLDxQMGg842PZvP3TFjxYY/k7dDjkvBGXRj1Gh1M8knhsPQkYmTw0NB69kjixvKjveztvObE890Jvu/dvtrwazXm76tyPOS+hP7mVe2G9R+Y0vE+Oez1h7Gw8jl1gu8Qv8jy2MZi7j9fZvHyyurz8hTi8btTTuwrCDby/6Q07t8AWPEqif7voSQM8lohnO7NO9LxTrdU9CpJWPOmEkTw+cW88dKVXvGi5KjxHSf08JM4EPA56mzyFl4e7O/CivF9Wgry0zsU8qxi+PREkPz1WAN86ljQCvEKPQL2GNMM8n8BUvPLFbDyfa709H7nuvRw2krxqcIQ83GSJO4Q7mT0o2F88gDVzvSTAfLxOTLu8uPvsuyyZvL0Xl2I8dP08vOWQSjsQFo68X+CivMhntryc+J881iifvN4aPrxIKlc8RogDvOhSHzzi0Ic81xdLvOznV7vrrKm8LHaNvMLkGTybSuQ8xMiGPH8DXTwfGwi66f/PvIeQ2z1DZeI8sCLgPF2AVLynQxE89KozPQKTEbx/TiC9d3kFPQIJ+DyiINq8GvyUPQsp5LqKjRG8qIsTvDdSDT0Ui0Q73a4hvTghbjuZkOw8l0Ygu1u0sjviVb+88LcNPMQGgj0Xj6W8tmuNPAQr1DsuXqo8i8ALPGN2mzlT1ae71dZGPR5bhjwSWgk9A57lPSbC+b1xiSs8+aKdvRcgebyHoZ87u7P9PHnZB7zNwP47l7bTvAvgOTymZRa8y46IPIaQjDunTzM6s/3eObXb/Q=="
+ "[card]\nname: foopizza" "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"
+ "[card]\nname: fooxbar" "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"
+ "[card]\nname: hat cher" "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"
+ "[card]\nname: hatchery" "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"
+ "[card]\nname: hatter" "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"
+ "[card]\nname: indigo" "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"
+ "[card]\nname: indigo\ndescription: amber" "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"
+ "[card]\nname: literal ! marker" "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"
+ "[card]\nname: literal !% marker" "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"
+ "[card]\nname: literal % marker" "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"
+ "[card]\nname: literal marker" "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"
+ "[card]\nname: north" "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"
+ "[card]\nname: not cobalt" "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"
+ "[card]\nname: or" "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"
+ "[card]\nname: orbit" "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"
+ "[card]\nname: other" "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"
+ "[card]\nname: quarterly revenue" "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"
+ "[card]\nname: run gate" "PIHXkT1sKlK9SSCZu/g7V72AK4i9Tbz8vZoxSDxvVUY87FoLvQAxoDw1j6875OxRPLbAZj0GsXO97BmbPOilXbuBGTY9IT9avTE8MD1A9Oi9Tjq5PaNsF7u9EZO8/STvOvz/Hr09Ymw9KSpOPCy91T0Knfc9BqAOvH0asr2UPU+9dZiQvAP6xb1ePjm9H4CDvKOnkD0XB8W+DIBfPQsKTL2WldI9ihGNPZtcTLyG9TM68BzXvSGIIrwqfpC9uaiqu9KDa7yCYsc8o+oAPY3M/rzFHFe9FwL6O991Qrxhudo8zmDfPQsF/j3jUg48wNVtPZyrSzyHlRc4hp9IvSmJh71bDX08d2LmPT0YnLwmBNa8mkJ7PNRd9bzS/II8dx7uO6nSnjwEyza9gEzGvBoVT7zNJrQ8JsloO78RGjz7qs094fUhOwDExTy10xk8w5kMPB6i0rubtdK9DA54O/5XDz2VX1Q8KR1APMd0Kb0J0Oc9aPIWvFmSlb034fm7gmxivQHk7jubo/Y8IuR3vPMkizyj650+AB1lPBvr1D2FT6+9Ya8HvPseO70fH4i6toz2PRHGF72BzrY8qljpPOIsWzzMQD07RHfxvAEHq700jD69E6oGPPX1Eb0KCIs8iM0HvFGcnTzFZaE85rQavBzFSbzIJoy8+TyhvEiw9T0bbfI90fnevK3xjrwufbY9qr7rPQDzur04KJ29J+5IPQojED0LYW28DRgZux2t0rzFxLm86yDDPRhNzL0cSOM9TGjEPBD9JrvLtgO8TgExPFJNw7ykx+c8FrbCvVr7V7uzy0889/eXOoV6vDyZbeE9in3+PJUOAryvvJu9TIXfPJoSPbu9IMe8ifdEPYKrbjishS68FXTRu2m1WzuvzEq9fg5hPRMNWLrsrD29CjZDO4i0eD2aIii7koC0vA9Brj2lH8W9BaFWvWyRQbr2X2+7XXogvNEbpDuA7W89SAiOvMdmfrupxFy7iAuTPY+Vpz0b9zq9S1CAPA5Bar17mkg9zC70PA4qaTxlOWM80Y6FO33tYT05b+e8DkBmvQwUyDyGGJa8nBTMvc9fnzyGAP285shwPIRW9Twq4lK88RDaPZLC8jv3YxS9L7V1vLVSer0crSC8h+0HvJcKDLwZGhU9BGrSvKYnhDzLR8W8BGQ/vZ3SaD0xk188rI9lvWDWKD2l1kC9HnjCPYrw6j1L5Vs9tI4jvC2w/T0Vsla9raOfvSq+br0XMDM8fE6nvRRb3j059nI8+TV0PF4HqLvPt3a8A2nmPFnZp70RxqQ9m8E7vLZtDDy6pkw874OSvR+49juT5cm9FbxdvSGOn7wllIG9mi8jPJwFez0JCMQ7L8kIPRMf37ycx2s9EOJDPFAOzzuram86dSTQvNQdZby3nL88z7GsOyzBtzuZtX08lonmPazdezyz7sq8/s6ovOQ4PjzeMWy7MbR5PDJq5z1Cyvs6mppLvLT1RzxoQoA9QPPNvE/csDwjwfA9LMonvKo1FLwQxdk9Uuh6vCg5j70nXbk7ufg8PT9xZb0iMQO8miOxPE6JbDyckO68crdOu95raTx6V4o80RJJuacfQjuMad08UNrjPBFBzzyEku09EK3wO/zvJL0HnfS9MpO3PRotD7mW2fm8lxTVPUJ+8r0MVL280F8jvLgHcDxca0i8kj45O1dxcTz0gee9IVKvO2ij9j3KRtI9YYWJvN6cfbyb2Qa8JvFNO8xTeTyeiqE9CHphu/ui8rtftqG9GIuYvH1ewrzEut4851f+vSGfNz0PiL46ogm+OqTf4TynFOI88jD0PNDzxLwnkPc8kMZeO8jiwbyxSIS80tzTvU+zZD0vlY09LcrpOhpJ9rzU15s88GF1OzGjBzzVr4s7kE5Yu4r/gDqp0Ju8rFhyvEj9NbkayaS9LSLxvPNBtDxIEbu8XPzxvDPtTbztMQU9LLk2uXNTaDzDZBM9epakPFeEdb0F5KY7UhmdvQr5uTyjO/e55aDqvWJtxrySocs9NQSGPKGZWrvvmtQ7qNBcPMZrRr0cKjW8phFKvGPsELzaDI49RnSgvQvcML0tHh677S2bvGed2LwYVha8ARKpO8Fwl7m7d6W8rx6+O0KvTb1UsvQ8xupAvOCKsbzsbMU9JV8Juxrh3rvKMn08IiI+O1qQKzwaAxA8+yZuPWr2G7xe+b29JVrwuToyeDwgvMC9MrQ3vOVhij2K70644Ma8PN2xrr0iZsY8L2I9PK7QUz0dKom87+t6vOneRLyNZ2S9IrKBvGVSsLthbdA8JivAPSDhWjvcb3e8EqUIO42w4ry6ToA86HeaO7A6hDvAhKy9XkxSPFnLiTyxuuQ9FDDuvWsYU7uQJlO9Vm2tPQZYtzxfdQm89DMHPA7hLb1DqHG8dv7mvDdUBDnU21A67azBvBdNdDtgiLa7lIFkO/25Y7wnu2i8ucjTPMiF1T0hJqY8oU1GPMvDkrxnAFC89qS4O//P87waLe29TPNavDHJwrzmtp0764ViPUN7oj1MZJ89PypSupG9bLs7YyU8p54aPIxIYbx4JIQ8ryoGvTvjBrtfUwu5sk/uPL2J/r0Y8g49JVIbO3iZMzto7hu8QP74O/e+kD1muGO7GRukPPyXLDydA4m8uxPNvL7weDz3xFY8u2yhPYxM9T2QiHo6phWjvVa3qTyRFGK8aXpdPNPN8zwo9tU8hHaNux2ffDyM+YG8wnOIvJde3LyiOHY6XwmVPMjuVLu+F7G7Oyf5Ou/ui7z1e4S9MsP9u89cJr0jXWe8E/h5PIVSrLw1Sii8az0EPO5RljxWQQQ466VVPOBM9DstotA48fDLPLN//brz1KM8p0BaPSdn1DwMphu8oZtzPIrUBbxbWna74rgxu7+tHDzfFtE8eBayu4gECj0HSUy8zNOFPD3c5buMfk09FAKcPJD+LTvzkSA7HzDOPI3Enb1fNnY8wSkAvKrpBL1pYxa9jPnevSQG2jwXKog8uE+GvQvTXj0f2t+8pdPLvJ3ZdD0WakQ8Ba5zvMzEnrxHqe68+glFvGr4lrws5ne7uvoWvCYPNr0OvWS9Bu23PDJZXDyWQf48WdNfvAalqLp9yYq7o5j7vJ+RLD0A6wI8XWGxvMxjgryLmII859PgvNpKHrz266W9GSnHvHx31Lw60b26hrT2POfNuz2GQWc8kRLYOsT39rtvrYM8b3n2vF/VgztcSjA84EP4PT5cFjyYo5y8iZOBvPZgXjwvHGu7SrYaPONUODysKbW9SKRiPMI/yrofcNG8kZUZu9zesLt8ikW8IVPeO6znLLzzUNA8ZPtXvLusBbuCFAE8l9dWPI19tDuLsZk9c2EjPNfPZTtDRrm8mOF5PJUTuz1YzWS8xxTOPJsoPD0gCkg8fGQPPJAzqry0psA80Ch8uqXp8j0HAbm8pKP7ubGoPjqHhxo82LlfPQGXYz0RmQU7y+WpvI7mZL12Tbk8BK8FvJdzZzzhofm9jTIIu9+HyTuwkx87VVQZvKyc8Lye6Lc88YgMPSeJWbxdWYg8s6G2PZxY0rwX5EG6YFqLvLgymrzd1Au80nGTu42D97zyI4s9UeMZO+63sTyeLJY78DazPJ737Ttxk+I8uAI/O4kiVjybRIS7v/XbvaS0gD0MnGw7yTxyvEP7L71Cm9O8zpe9vCpgrLzOTDW9DpKqvQ94zD0ExUu9iHgKu/WvTj1IKLO8AJsqPTsEhLwdkii8ccwoPBnekLy8gZ+9B1e0vUKdEby37988lKTuPFQ9lj0KpV474KD0vNrNpT0KfU881krdPJaXT7vhGtU7q3pHPVeCeDyMyAg9PCJuPH3d1TvMbJ479x8uPQJFPDzDUng9V57zPFDxo7yJKkW8AmRYO73gLT0W2j25KSUsO0z4m7vVVGa8k59svOLqPzxVjR49QNfCvRnArj2BGK67psSCPO7fur1JJ3I9NHJevJwMjT1Ks0m7Gj6xvPtDFLzisfs8RES8vKqq9LxksY080hteu6oeSDyotzE9I0EFPUxF4LzV/Y672fqgvHNLdbyqpgS8+N7xvG0ctLq5WD09NqqsOV4wMb0mODG9LddovQCT4Dw9PAw8tXVWu92OYzxU5iO9KPqSu0dep7wjAeM8i+XEPSRy9Tu8xwa714Vuu7Qfzbz6xYU892N0vH7M1LwTOfy669ciukZSQTx3TAQ8lwaovClWSL0AZnW9DYqSPSOYsbwXo9e8tLh5PRojwDvjuNy9pfXnvMDtBDwj5sm8w8q8vMP5zLz91d+8HNZTvQ8+S70uYgs8B8JBu0eDer0+a2i9Hf6TucObH7xj4eM9UrgqvBOebr0l2R+7UFELPYSpVjtC8tY5wBh2u7+atLw+7+y8U78DvSvLVL0Uf7E8dxTFOqdQN7wrdRo9NLSvu9aEjD05i1w86cU9Opuq4LzakdS7U0J6PEoHGb0bMmy83Hjwu6ihOb07kba6t2zTvRBp+LqG83I8HiZ9vOEXn7vqKYY8F+hAvEp7TLwHYNs8myb+PGrabjuvTFS7aDHrPC98Nj2OpBA8m8gCvMJHEj1N8ba9WzqdOp+TWzyWsVk8hpCgu8grirzXys+9IvlDu6SCAbvcVIo8e42pvGCi1T0rgEK7xt40PQ1KP70VEsk8AiEhu+MqCb0Vjjk6wWqVvOrc3z2ZURi67npBu4ejXTy6At49G+pcudHgljw17tU9hZ6xvP6K6Twceym8a5vCO0Y8zz0VBa08ydp4usaGHzwSjBm9KdFmPLGv8zu8C3E8GrCeuxCPVLzYvzK7JDI9vNarrL0zqqS9AMrAvF3aJT04W1k81r3/uzRYALz4erc7tnGrO/oIiDvg4Um85GIaPDIOs70b7nC8R3FoO8QHf7zhdmQ5gKVwPGY/fjwfAsc85l8bPFvQAryETP09EyJxvIu87z0QSDA8RdrjO5TMOr0WwwA8+E1svRB2+704ZWG8QKL1PC+4TzydmK68gpyhPAvVJryl99g9Mq4svRrXazzejcO8yAExvQOR67ynWOW9DaEAvAu8+DxRB3q7yjEevQs8SrzVUKK9E8PRPCnFu7zgDMY9BkBwu+ImrbyWF4Y8lkJ3PLZBSLyrKjg9J0wtPQmF4Tvm+e88IWVqvJeAuL0hLlK8byrFvFARI7yvkq686Xm6PGQhVD0EPsW8rWQGvTZXcbw+JzK7qe5HvQaw8TyfH789fmeFvE8XBbyHU/K1sG6oPIDrgjx+qgO8OcR4PRG60jzLSMe8zIPmPUf/8Dyt+LC89UUVu9xHGzwUYRA8UlZZvUYJfDsYS507C816PEYVtLwmVce9Se2cPSAZvzxauRa9WxzGPHNLM7yn4A+7VC/+vKRcO7xS9AK7cXodPNR9T7yg0v08huvSPJm1PL04w42822KRu49FN7yA9cq7leH8vD1+rL1VSTe85ROBu2X/ZLt897+8b4UpPEEfKbxbxuU9S6V0vEmulQ=="
+ "[card]\nname: run meadow" "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"
+ "[card]\nname: runner gate" "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"
+ "[card]\nname: running garden" "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"
+ "[card]\nname: running gate" "O+DgUj118Xy9RLG4umt/eb1rjIW9hPUnvYT0qD0Uo5c83LTTvQ7M+zy6Ave8l5XRPRXTDD0IVfm91hPlPLDWnTzQYUY89DudvU4hJT1jpGS9TVx8PZ1++ruPENS9BVZiu5o6E70yu+49KBOVOVbmST0S2aI8Ga4/vOUpIL2UZ7W9aBeHOalsdb05apu8tDxqvQQlwjzqQHW+C/4HPUjErL2NSN09hQshPa3eLbuNB/g8qc/YvRKjAbvtxva9yR0pvA3FYLy16BM82UsMPXHYhLxdtk29BFeku4U4pDyzC9o8HgrvPPXVdz3Fbfo8ryR/PatURzx33Ho56jIRvRg7CL2CKpE8qJDwPRz8sLzjlfe80ZQTPFHTw7y8fl48WyKaPAZjqDyHcfK9khSdvCf3NrzSKn48h0hJu7HnWzzXrqk97s8WPARo1zydBN48Pf7EOs+IBzocg7e9LO0YPH7JqD2SY6I7mouLPNGndr053OE9PzZWu6/AK707YoE7htV9vRCPIrwYirY8IucVvMMuiTzcSZA96B6ZOxU5mj19nEe9X/DRvRlgyry4+eE7tJ3iPRaQJr2ATWY9Mua2PQZxVTzboa86HeK2O/UHAb03GAW9RSx1PQoe6b1ZhqA8GeO0vAC+IDzGe5A8KmEtvKYQhb0G2sa8tbKOu7Ey4z08sYA9wvCmvJDitLoXvHc9rQMhPM9qRr0gWcq9MQUMPLJcgj0Jyyi8g26ePIhG7r0lXw68odV+POBviLy0TDw8vvKRPIAkBbvpPXC6X8K8PHqSSrzFz/I8UagQvRi487w9D6c8+Vx7PBrfzjxpQYI9bD/GPJOS6Lxpxhu9T2P0PI69/Tw07dy8bkG2PYIpd7uhdF+8iB6XPB6RzTxN2n29cFdqPRShrLxBC2S9DRteOSP1rj2xBEo76uJTvCyfBj1zIai88WLPvY9siTsu/8Y8DepvvNVP2zv+RQU9cW3CvFhsibqA2nu8Sb2yPZDLcj0donG9VEhhuw4oiL1f9Ps9yWekPGOwVjxbrjg8129dunS/ej1u8kK8ChPpvQ1nQDxkNRy882ySvc6SXzu5UMu8+bgVu9a6mDvkfXG8xRkGPYiijTzBYAi9K0qevIoSir0pcHO7VcDKvH9027w4XhY89K+avLqaZDy2veW8pMmAvZ/jRT0MRMk880M+vVr+fj27AQy9BXb+PVu8BT1mVWk9uyY6u/MMMDzEV4C9qolrvSqn1b0OIpo8vAekvVOg3j1uIlk9JOc+PFVXnbutkX47LPEWO0MAwr0rcuw9gcZ5vQ6E2jzLtoQ836gBvTaJ0LfxD3W9BcWWvTQ4nzu9gvq9fYkrPJukFzz8Lbq75p4wPQaWKLzAWNA9JYMIPKaJBDv1fZY8E7ohvRISDLxW/ME83voIPFRLKbulvfw8guwlPZZ3LTzrtKW8n8nVvOBy0jygesk66WnHPImxeT0yID47sQ+YvNijdjyOfts9HfbcvG9EJDxlI0w9LfY1vLI/2bsviYE9TuqVOno8R71jJmo8EXSPPUlpzr0b3Km8uIOuPLyShDyd5+a8i6ZGO7mfFDwb0os83/ocuiS1pTwcqss8GavoPB6zHjx8vzo8pzTmPGjVm7zkg029WcfhPRIHqjtMvMm8l0yHPWWEYLzf3eq84Uvcu7f7Hzwcj3q8ms6bPCAAAzz26ru9LaoOO9K+Ej270nw9kQ78vQYTB7x3Fzy8CgHxPBp79TxF7A89MqtLuo75Dznanya9OGWmvHtMKrzoRDI8qInLvStCdD0Qpce8a1mvO+kejTzVX/g8/HUaPK7zjDu4p4s7qrmnu40x1bwYRu28vSTOvTErhj0U3GE9EEQzvB9hSbzOQOY8rIapO8gIIDz7KTy7Bqg/vE+UuLwCyIe8zdi+u+Nun7whA6G9IPSMvH1LCTy4g1a8CU7NvA4Fi7z3UJI9KvpZPBzbuDzOdqA9h443POQpqL0UvwG8MsU5vQtc5DwBSO66rQk8vVYQ2bxoURk9CfJPO9LLBbxIMG+8FeVtPIPdv7zsLAe8VQQMu64LTbyRd4o9RxjKvO0Azrzn91S8LM+RvKpMrryBNdY66uHOOQtieLuNnou8+5xLPKctzb0ky3k83gwNvKWRwr0CNgE9OFWVuMjj9rw21MQ8HbzFO56rqzr06Vw9AXKLPXbVkrydbre85EtuOOeouTtIx0q9Q75evIIjlz2J8Cq8NvqJPH5psLytHgY7wJhIPLztnz1NLyC8Snc6vD8sQby8Y1m9KfZOvFsuxTwN1eo8il6TPQpzezxHH3u7uumGu+aZJL0knW087KocufWk9Tu/T1y9fPOfPCZxBDyKdds8v0XfvWtI67oauCe9LWLMPRP52Tyj85C8vl+VPGnP+702zxW7ESywOsNsbLsQz4+7Jq5FvIC/ZTxFjIu6d6eMPDFSV7wGUQ+8d5sKPGnwIT0Pwxw8oSN/PMUwdLyXDmK89oRWPBjARbyCjlu9NmTNvALt67zFgRQ7gn8IPXBXlj0nEgk9LVx3O9T/BDxFxYA8Kp8hPIkX/7yNuXk8g9gRvTL5i7uuPxq7RAazPPdsdr1IEAk8+JviPLiErbta2wq8oM0HPHI5cz2IDAK770whPQqOoDzMGEK8iA0/vO4N7TzY6ZU9EpOTPXSXEj2gq5O62yqXvSGLCDzw7Le8qnPCPQmhJrqSjwo8ykHvu+11wDyIAOK9GhwfvJ/2eLyKlIo8EdaQPJXQUrwF7L28A//GPJ+n7b0BFmq9O51hO5ZRY70I2Cm8D2jVPCx8R7sDcC28ssF4PSv0Fzy8kEC7ADvePOfgGztaUac7jJpVPN85PLsRdmI84BYDPT1T+Dvf6Ym8y8jxOj3ZC7ybEV+8EnXPuzUAxj0bnhk8g+CvO4TWBz0FTFi8vWsPPIXeFLvHCME9J1mUPIfC/bjd3dI8q/5OPMv1vL0oan08fol+vFA7E71lqR29mLnRvSJ0Qjugp6Q8jKFfvPySUz0qaXi9BtNDvElHED0Osjs7j4OEvNhSW7w6Wsi8vD17u6ICeryKcb87a9dLvA8qY70qZCe9OEVYPEwFjDzSGcc8aIEyvCLGRTtEeQ28im36um/KmzyCxKg8mp2XvQslHbyRCbk89SRtvQI5/Lzk7tO9BAMpvDQ63LvrzGG6hRACPRdgEz1xS/o8jK63vB1S9LwhLNg8TTZnu7yjfzttmHo9DdqkPRlxKjzhgPe8i4zcvMncoDvuPb25kkV1PNgJBjyhFdG9HdSIPLBDfjr4KA69A0Lsu/JGL7ucN1K7iPocO7hV1byz4e88dmOyvQav6rvO5so8ieWoPLqHfToYTJs9bFazPCSITLvOSby86DhePGrGlD12pA+9C7tnPCCuIj04PW08lsCjO9ruE7yfC1I8icZuu+jAej0UM3G9ABpNO5MwuDv1X1E8poqvPNAI2z0oJzs8HE7pvLuB4L1ZMCk71Ivgu7eqgzyrGVa9jzZKvBA1Urw01ng8lt5MvJqXf7xJVLI83t9DPRLwT7xwkFc9IdpDPauTU7xZh2E7tkuavKW1W7y6DbG88oUTOnO9H70AUzA9L4wCOqEFEzvWCbU7rxYcPKIOHrokjiU8lM2aPAIqSjyZ0iq80KgPvaCUfT0NWEo8MBZpuokl971hn/y9BABevAfKwbyrwqq9En1QvLh/PT0UZky9cpivvEzIST1SikG7ZZdCPUsR4LyFIx28Fje6O/GJXLxpCsG9Ewh9vWCL5LylBqQ8xAp/PEL9lD0U4wG8JKQCvMJ8uj0B8Zo8zgGYPJgh1Lxj+NO7gbBpPU4I3zwVOcM9JrMXPA0zqjquWXs7+ER3PRVAXDyLu/U9GtENPI1IVLyiQXe8c6x5PIRzwDzA52K5xytmOyYKuruQW2y8oheXvQIsCzxTUBY9P5LovRAPOD1oUQ08C7fJPOEqwr0/oNA9Qs1+vIC8yD1N5ji7CjoxvLTXwryWTEo8KOn0vMLFLbyPLi09BMriPC+AijxdZZI9IjCTPSKGa70TGV+8YYzgvIRJBryqzUC8mgu+vJdc6rtx64U9QWMkOeD+1r0k+5q9MtaqvI0rKzxyK5o8gLM/uZWhsLaZfhq9FFc4u+9Qs7ysouQ8okX4PSXemDyYvvk7r9Jjuuqz+LydCZ88+njBvJGpubxRbai6ADV/vCynzDyYeHQ8qx0cNe7F+70p/4e9NOXOPScwrDySD7O8ldsAPQH+BDwsGxa9n3c7vMMYbjs19ii8u1O1vJyyuL0wNWC8Tu8vvRxwJrztO2I8F89xu+owsL09mh69HaqwOrHWZLv+hEg9LZ1/u+Kpvr0XWu85pI61PY4eGTvEN3y8jXlvOqJ85ryhEOK8PyFTvShhb7zz+dU8cOCkOXJrSbxrrR89bGp+vL30/j1Eya08uahhPAmy9rzy6DK8UoAPPA4g3b0VVFi86/noOiXK170s3jM7kXrUvQDJQjs4q7O6MYL2vMUPjrxVPz88QC01vIwjiLuIQGY8jePWPJ5yRjweZfK7thiPO7l4vj2Fh4k85ivmvMZwBz1Dl769gCWpurEphzw7RVs80TkCO1BmX7zUuoG9L1k8O33e3bv2E7Y8Y88jvF6cLj1VJaG8HcYBPMhcVr0oVUM79C1PvM49vL0Ufxe8Xy1wvIYESz2G4I27Xb3wu8Nw3T0B+6Y9CEtjvA9FmzxV9hA9hyhzvThDETwtDnG8v1tQOuTPDz0OoCg8y7TVO0/sHbv6x+O9K3mfPFPAjDwz18w7F9CjO9Se3rzd7U46bvvBvKzkUb0D1vG9C6WWvJUNDz13dic9DWh/u0XSYLzmt8g8JX/ZPAn/0TsC0kG8QftLPEI4FL03Vsa8WqGtO9FoSLzfcxQ8FtYDPI9gCTxQzuY8/a25O1OzAbytreU9LfCGvFb12Dyb3Mw8YVb0OwztNr0Ine08tuf4vOw4fr01Ska8mUScPEAnqDxZL1y8qL7KPJeasbzKalo9A9G7vOsEbzy1kYK8rK7CvOAx77xtORy9IUlgvIMejzvDmIC7baHqvOCYPry0W2u9FWKcO5odw7z0KZs87E6RvAIL+byNFGw8VGiVPN6hdbySjZQ9FYZUPQA75zwMAmk8CnysvI0AGb0KmCq8a5pTvEQrNryKM5m8zRr3PBuwVTxYbkq8oiTAvRaqYbulQUC8EtppvRkcazzBtw89g+nhvK9bx7yrYGK8FlV7PJLFdztoW0a8zcrvPRKIPzzW1yC8vMqrPS8JfTytOZW9Kl1PvGKTkDlPaUw7j/ySvUjsIztFsYM7lSK/uxzjtbx2O4C9Sv+pPRmEyDyPMBe9eyx0PMXDE7yjnOU75vB4vLEhKbvh18G6rVXtPR2zg7zODdQ8575EPQV/uL1X7768v42ju5FThrwk+GC7xaB7vKipu71ICmS9Lnc5vBqepbwfoHG8GKzOPLmn3LydBZ89AjcQvMfKYA=="
+ "[card]\nname: salt and pepper" "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"
+ "[card]\nname: taco" "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"
+ "[card]\nname: the" "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"
+ "[card]\nname: the gadget" "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"
+ "[card]\nname: the widget" "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"
+ "[card]\nname: theater" "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"
+ "[card]\nname: this or that" "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"
+ "[card]\nname: top hat" "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"
+ "[card]\nname: widget" "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"
+ "[card]\nname: xacb" "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"
+ "query: !%" "PP/DyT0cdTe8GiZ+vQZ4FD1qWEk8qxnWPFTYV70oiSC82qovvYSktryx5m26gHdYO+vj6r0TQ947zWcJvNATnrwUyHS7iiw9PAgcb7wYKlu9BbUNPVp6Erx448A9jZ5+vKd82rwk9Q+9Txl/OiJpyLzlHqg8hCsUPJGYojpqtES86BY2vXF89r0vyWM9JMqZO+PtCL2MDfi9v0yvOO9Tur10GI27mYVrvCnLHry5dJq9JJW+PUygNzx3Mug8REPqPSmbOzzGICi9H5VgPTVxiT1TaDi8RFg/PV2+7zxYX/S8mL03PJBa8L0nNB48raOHvE7C7L1DAZy8ggqmPRjylLyopPE9Ri9Wu0Q5QT27lMY8kC1QPJ0BgrssBcw8Le6JvSWdob2Dyu69gHPUu9YYzj0VFv+9kc8dvTD7+zy1m4g9mYn4vSnC77zgmQY7jAc7PVLpXTyh+fu9V44vPV97Hr1Dxv08sgrrvQRvY72Ph4g8i8rWu8ICZ7yRghI9E6O+PJmijzyqa0U6e+rLPZoii70MtRc81PY3O4/x5bzPlf49SsZwvaCL17fpRBu646IiPJoffzzin3O8mu23PConkbwyv8u8f9vjvEFtIbwCxpm9n8+sPPsyX709cwC9EQTEPYe9MzznMiQ83dJtPItwYj0Mske8nkC7OxmtrLqIyxm9IjtjPJ0PgT2YxJM8w4khPIoVuT1QKnC9ZFVIuoktdj16pHq84u2APEC2GDyDH/a7vcx/PTI/x72OdzG8vEILO3jbiDzkrKC7gI6hvXhaRT0stMa82fPouIJrpr3R/jU8ZUjLvZgeITxca7Q9crYJOYrCkj1ILMI7VSauvQcbyjzM+oq8wtrfu07jzjyk8rQ8rm/yO8xiV7uJ3ui9mk/ivV9Ap72xprA8JGgGvNf1qTzf3wU9ZYIGPL0fAb2UNYu8UISEvHvkob0bDaO7+mwcvSwttrvOYe88X2gqPJeW57sQSgW8i67yPZLayz0bBOK9QI7KPQq+DTsLX0S9V76zvNQFOr2kjy49c3C4vYcYqj2A45Q806kRPLeDkz0f2HG8m7L6PEgkbrzC+NY7GcyavIsGmLyJ38G9NCCjPN8Joz1jaE08FvMvvXSgR70vonA9hU9uPHg/lL2PtCq7nPPZPXT5d7uX4Cc9CyujO+1cCT13bnu8YiNZPBVHqD2nrCw9iifRPKXkyrzMZve8iyusO6In87zbNY88MXf4vTaqATz5cFi8G2sPvLJ0IT0dKEM9GRk+PL8UiT1JrjG73qd0O+1Cqr1YG/09KH8cud5l2LxLGvI9jyfyvPTkwrw8WsK8BbwavWJLizzKoLg8fmm/PS7HBjuW4OW8+lbJuqTmNrybMRo80wg2vLwpWDwSAxm8Hi8jvOYRPLz97W09AyLyPRlfUrzRydW8z1I9O34Gij0AFCQ8FGldOYlivLzD1Ee8gQeOvHKddrzemnQ9KSA4vSy4aruoHs47lUwQuxifcjwMDzw85FbCPFlj2ryqNla9dNY7PA2UcT1bobs9JN3zvGSghDsBDS67f4nGPGPKwzzxT0m76UAwO7LK7LvYKMk8n9EWOcCFIT0jZMo7CCmYPWntQbtVOD+9N8PNvFcesDtFb467kNJmvMmttL1d/OG5pBKtvKo66zwMFj49FF4OuxOmULyzhou7gMSNvLe2OzxVDXu8TO3kvAbvfjxDm/y9BVqaO9sRmLuyUsS8WWyquqaazbw1nwg8ych8vZLQtTxgDMk8AJ/zPFEfej0IoMk9Fb4AvZ3Z8D0UlAU7tk0LvGK1tTu3jei7zo1VvKFlejzeKn87GKpDPSR6Tb1Cu7s7xKTlvGXJ9DzIwZO8hNBIPBiiaTxGqH28hZWsPOVazT07THe9GBJgvT0N/b03fdk85XRHOxZUvDwfb748qY4+vJUs1L0n6qo8h1cnvUx2w7010OA9B/VDvLMyNzwsK0O7Hyb6PK2/b7zAzFy8ikk3PURMPzzupE08r9/ZvInZFL0HR7e8D2CevCZRXTywlW09qH/iO4Ak8DyIFZK6OiU4vLuPQz0+uZ885yhEvVlQZj1JcCS8LVWZPUz9aDzMlBC9iCHOvJ4CbTxQz1a83SG1vAqAK7yiBhw8Ms+CPIBGh7xT0ZM9AmwsvAApsLxoyHG7rp1BvHWO+Ly+veA654YCPI+CmbvIpsE8gw9FvQhj1Dw2tvK9CwxCvT7w/r0ECZo7/Al3vSm9YT1zq+A8SYgkOmuVB70LXMg8YEQhvSjxnD0Oi4484Jb8vNGDhDx58Zw8xaU8POQBULyBU0c9Chz/PQtiV7wIAds69fC2PLR3Ojzpyhm836uivYhyXz0tiu68+OW8PIB7zrxwhMS8v9UuOF0Wdj0dZWg9iUWmu8E6nL1YEJ08lxSkvIVWNjvByVC9D+zPPR7ajb09BY68vN3wPWz3K7vttjg8o4B5PaPrTrxkdlE9MwzcvW+Cj7wAUsO7rxeTO8lh+T1cOrU9Jraou2IOVjyYzJK887A/vJ0xtzl8t4M88z4BPMtVf7z2kpM9QTFHu8oYmbyxEmQ8C1SnvIx6Arzbj4u8KtaUO/7YlbvQdV48CDStPOcf2z0/n6E8KDILPSSjMryc/mk9O/wwvFpxBjxg2p68qsG6Og+TzT0SmPe8ypDgOycXCDzHK1u7xWw1vTokxT1OajI9B25ZvZpNh70a7P08fYbdvOQ17LtisFO9CosnvG1Q0rxJIEy9ZapFPNSkp7now2A8zqnBPTpKADyNZve8SzQwO55rND1Ucbm8K+ZLPF0RpTzumhs8mH/+PPRABDwdrdE9CtgpvAUT0Ltqeu67lI4gvUeJkj2fjOK9buCdPKPILrz9kj685zpEvGlDCjvTfBc7r6XVvQ99Nzzc0xW8jzs1PNK5trwJxPM7ojOIPGikGjzq4208QAQwPEUP27rvUdw6d1TXOc9a2rwrzii9c5GnPPUU5L1SfC89Z8fcPHT5sr14N5u8+yqpPRPxXLzpBq27/JmNvNZMi7xpZJM6SNM5vM807TtrFfi6lNaPPRUrmrwRuRE9kcHau/9GA7z1WDS9AP6iPOFVLz2JeWq8m0BFu5qI+zzw2de9EAanvJ0v2L0Neto8kaWDPM7Rc71n/q27ZLThPQIW/bzwOSe9Nn4tPU5K8bxkTn86X7S9us5hSDyXQQY9COJTPUJPljvnqv087XKjPOWLezyLbgq9R+EZu7wSJ7y4/Lo9MBVuPAx/Qj044Hc9UHbZvJkM/rxVdNu9G3i/PNJd2LyjtxU6oXWVvSkuoDkYRdu7CTvMu2mcUj1sBQg8AK3Bu7/e170f8SE8gnQZvIcWATtdERA8CYVBt/GIXztZH2k86MXiPUYfwLtlvMW9ErppvQx/PjyJ+3Y74wZQO+VtRTsObcs88gYjO4rvNDyjb0E7QWuFPP5tiT0s3V45SApnvF5gg7yGThM84sgMu63aozu/JC08uzvWPMyTuDscgYe8s2dBPPzOuzoe+No8PTa+PCIwl7yF8Re8dL+6PFwItrt1eP48LdiBPQ0ZqTyCyXO9OA+JPPn2ZL1Htas73O1gvECwnT1NIhM9BC14u+VJub0EDv882IESvSbiGLsRulM78rstPFzWD7y9eAY8rA3tvJyN0ruKBUA8G3ONvGX0g71sL6E8g4Dku6l/zb0Je+I8fPipPG765rtTpSC8HFZFO3H+wbzj/8a9Cg/EPYTcfjxuayK83ru8vNJmxjxgnCy9fqIou4CNNjzhgPI9FZYSvG+p7Dufs5I9AujivS0QHbs4kue71214PSkjJ7x6QKm9MjpSPTMUy72KKkO8qHmiuuQG7T0bzJy9DuExvTx+njy403s8Qz12PPX9Br12rCc7iKnsPJjup7wgIBu842kPvTs/bDluWY87giI5vISeTz0Xo9k9Ki/mvLvcwbunPC09HGXJuyLiPDzb9Tg8ua2cPPfJ871UZ0o9ZtJHvNB3jb1Qzgu8xS4EO8KInbtrpH69EJwqvIN8Pr1Kvu69J3ozPUNRab0un2u8BTLvvO1vUj0Uu/i9APhcvI2A5Luuu+q8iBdpPLqwxLyDFno8gXQRPTwgOryIStY82lmvPQH/pb1DlWa8omXlvOoQIbssL9G77ELHPJku9D06mDU8NJiXu+ZGD7zGZWi9CclduwL49rkhQS07dRvBPN6utr0jwsi8aKH+PUCAlLypswy8ITiNO6mlOzy1ANS7EYsEvVKVl7zZNVg8OC9iPA/UBTyOipC8tltqPOTiYzvvow47gZWCPDc56b2H91U8Q2svPJSXi7tpuYW8D3gpPZam6b0UQe65F5jmPUxFprxYj8o6iEYtPSV7CLw/3PA8qPscPNxa8zwuAec8dbw7O7nn8bwt4Nk8vBcEvOHB4zwdDNI800N/PCmBhjr5gps7rZMKujp+szuonk68zPTTvMp50Tu0qoi890b4PNlt1DytgBi8udAqvMT9HTxtDQu84vamPRAGyTuDDjA8MWJyvIl1cL1Ba8E9G7pCPH6owLy6IvM8i5PavP8aD71fdoI9J7jvPRLmgr0melU9U/UEPRaHYTylfYw8xomivVJgkryAfVS8wtVwuxnSG72OCGM8IpibO6yyuzwxdlY61zfxPLfbNLvIrgk6tlLvPXhw2bxb2U69EEpYvQFtU71o/JW803P2O2Oa4bzFtCq6AHUAu+XQ4DoQ3Py55MChvGsB7r0/t3m8dWh8vSHqkz0pfv08xclLvXdAOb0uIDu9cJEQPITJu7tJp/467J/rPQL0jb0xXKs9J3+5PJcf1zzBhbO9Kr/lvP0RpLrtEBu61I4iPQPbjjzTvIU8YEAUvJXYETzYwC+7y3MQvJhG9TyDxJy9H+gWOxtaPzvq3lI7LIg8vKqjILwmzBE8ANjPu2VNf7zk39y7Gm0bvStdFjxZ95i8gK3tPE52nD0o9V89CdvkPCelBTvqAn08YIK3vDm+rTsdVo08iUVfO3ScBb0gMmm9mvs9vQ4Wmj0Q0+c7nxAru1zA3LnHEB69Ba8pO8bUnT0ClL+9E6+XOyGHNLoh+fQ7b8c4PPUStz0C5fa6gsQSvGHFMTx8fRC82p9BvK83crySSx+8ObfFPDc8mjyjU2+9K7M3O1weHLxufA48l8rpu/oS5jrrhtM9HvyBPJJEubzSljg9EzlwOeryGT2D40+86E6XvAA9Bjz0u028owRiPD1ADLxZXTs9aKK7vLaiwTxhKPG8yn2/PEokfj0LuVa9dWxgvV2b5z0vv0+82IFCPQJ0FD0AKzU9B3sVvEipqLz82tw9KjkNPNQR/j1o7MS72LzkPSWmWbyjur884+Z6u5W6/jzWzS28xkfuPON+BjzGOcQ8l/b9u3wN17xlRpk8ujuBPR20CjyZrwq86VOsvTd5krxwip87YW5lPVP/OTyjxRQ6inIZOu7buzy3MQ+8wQipPTH/QTr/tPY8JfVFPT6bug=="
+ "query: \"amber and cobalt\"" "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"
+ "query: \"amber co" "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"
+ "query: \"amber co\"" "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"
+ "query: \"amber cobalt\"" "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"
+ "query: %" "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"
+ "query: -cobalt" "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"
+ "query: a_b" "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"
+ "query: amb cobalt" "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"
+ "query: amb or co" "PT3+Tr0uF/u8IIGwPN5J4j03RMO9E5ajvIsvO7qjYE872YRgOwak3zwhckq7+R+PPaXtmzyLUZy8W5tVPKTzFLzffBy7jklYvCP8YzvhtwS82YEZPcTelTrYnu08rLELvOK5VL0sPdq9ovHxPUfPCL2QyTA9FPirvVhK6jtmbxQ9q6MzPPkxLz0Qc7g9odX/PJQdyj1n6sq93sEyuirKRjttMuA8LI7kPFOtDjzCfO48ITQpPTjtKD0Kcfs9KHeRPam2QzzZWy66qkWYO4rRwjxTtBY8SJDnvEUnqDyjq4a85dmwPMd5TbsxVNu9M2RPPWOrzLzGcRY9SFHnvKeahL2Nzsg8+dE7PVUeK72k49g8xQQXvcqOoL13aTQ7t7g4vYJDNL1yvMy9aQ9HvDBC1jz9//29idjbPeih7ryusRE9p3zcPKybcTyR5Iu9FEQXPPToMz0RYTC9KqX2PI0kJLx3Mq86wrzsPFa8wL0qOTW7DYqtPOYps70qVTK8wexjPBjdfrxhPpA9dwFHu8g33j0Rfua9IVhZPZHdN71PbOG7ll6/vGMfuj0DuOO7dRXpvS2sGbyt0d65BSGUvKQrrD1rdpU9QNNDu44sBby0KLa8S/Nau6FOmTwQhTY9BfbgPAEtRbxguT09gbcAvCJfob1ORBi8jPnJvLY1g71PLSu8nwTDvMv0rz0N5xe9yS/ivbtTKr1g/ZQ9q0gpvWVCezyqrHG9AEDvvFS/7z0TES49Fe2TPJHR8Dy91PA7DN+6ObIsTDxfuYm89TRBPX5fbb1NtjO9HMPaPDY7VbwH/ge9LcH4vbMJBb0GhDW9MKU2vN+WBb1G7Fk9GuOEPSKko70Tanq8wyxVvN4VjLyunje7+0UNvVGIy7zBNKU9Ua5APUIvRry9SFS8J0OxPRiucL2jftc7LTlZPWVdczyWWCO9SijvPSGEzby6/Xe8yQlYvFJuQ7qHdS886OWpPHg34TyazMa8hlDJPKvp6z2JF+A8PbVoOzo/5j2dNlu9RLpjvTChMrv0xqM84nEOPRfqIDz1sEa8K9uyvWApfL0tp528WQcEPA8f0bzDfmG9h/u8uwQzhbzj0lU8n1ecO5ruzDy1EC08seUrPBheKzzSV/o9KLFiPNBQEL2EyYU5jRpCu9H70rwqqbq8PnTpPKrHyLxyY1a6JYgOurUwRD2g1hE9FxxBPD5k7byObWC8ZKQ0PEmeeL1v33M7Y0nhPA6C0z0dKe49gWRPvVWe2Lu09oI8g9qJPB1xqrsKSMK73pquvYYNxrzt3jS8xkvBvBEr2LzpFj09geU1PQcWpDxIdTu8KWLHPA00/r0VzgS96CwCPPa8MbyGD/Q8jlwZPROSxzwmpl082mRSumLC37vDBX49Fj61vREGpLztHlM9MvWOu5HXpzyIo8u8roFpPQCLXLwrlw29M8xRO7RH0DweLp69V4OJvRjbuLzKz1U834ZsvFVUp710Frw89hY/O66JuD0J3vM7IYOQvDfzKTyQ1M29LE4LvSPJy7yOnKk9IsuXvTWSErsCMjQ9LfRsPIBJxzyuo/684MjsPRiPMD0vUZW9Vy3HOlucBTrzFXo6gZ4iPNRMRDx0mYI7sOZsPOHeSz1XJPE7gOWIPFBs77yncKG8JuFZvTtrpryICTo8/ih+vSD8jzzJMqG7N0pjugM82LxkFz87ipaVvSpOZ7z8svU8ctGgO/DxXrzQaKe9Svu6OikvcL1Cis49ABYqPRbxTTwYBm+8Z1xcu2rzOryxATy7MxUyvOa7HjzfxRS74D4ivCLEpz04uCi8fyXAu6KXw7vpdMY86FPLPJqI5jsfdl484X1/vTq9lr0Z3JG9XCP8PYyBzz0LyuE7eYDAvArja7xoY3g7CFDfvRFUvLzHDN49AyYxvQyJqzzYY6I8WDrQPTLZVTkLFdS8v5WePC+AIrwYCk27J7gLunpbyjzaNZ89CUfvPUGO5LvVAsa9AlVrvGSuLT0VT9U7cI42PJRcrTunGr29KcV6vSp64bx+Vu+9Ck+ePIMOn72KyGy8yYB+O9zQhzyhP2g8kaVrPHOdFrzZ/ra8A3LYPUEu4TyHv/M9j1h7vG/AbTvY6su8+vy1u/MDQzyQp068gJQmOpi54r0lmoQ5OWCevTZgMz0BaKw7xQJpvAVNQDyAe267sqI5O0G5J7z+pgC8T4AIvGlY6Tz0lLM8maAVvOeGXzr2Zlk8TV1SPDKdO7yXWxM8uADuOmKegbz4LE+9LAj4vIlLDbvxWVg898vKO6xlrjyG5rE9YIeCu+E/9bwu2jA80l1TPEMq7buWVbM9CXKZO2VxDj03GpE8nddavHJdej0Nnso8leZyOugWb7zW1Um9F3nEu4ucTD0Rwqy9JTEpPYNsKbi+T3c9K7TuvUB68DzTQ927wb9duxunRrv1SGa9G8qhPCwrrj1ZjUY8CGFEPPLjorcPtmo7oZf5u8FX0jtygQs7p7XWvMbc57sc+7I9SmzDPPouLrzRaEm8cxDOvGZ4rb00zIE9A2KLPV91fjymAKO8npsKvWnW9j0gSto70HrdPGKPBDssV5g8uUl8vNiy8zwJG6u8p40/PMklKruJdeq8+/SqvS3EcjuhchE9ETb3vARBezzh/v48YPRIPSK5cjrzHx09lgCBvKfG2D0T/6+6wP8EughNGj0PA3882h3LPAVh/bzSJpW73CrHuCQTnLyPRiw81BV+PKA1LTzKLpG8+b2pPG/pETzDP968rBsGvJujKTuULJe8o8+qvEapSrs7Wl287b1iO7PG6rte1HS9DO1LvFgwhrytT6k8+u5QPA5Frz0sora8lzkxuq0yabu0C/a9Qw2oPRu2Gbt8cio6jiKHvRjWPzrNND287zUvvEYjm7yjd1M8noclPKR3bz1zi6C8h22cPYgESDyIyBg811eyO48xHDyrYU89A1FOuuq+Wz06vbA9XrFhOnkmPT0sBWY8sI+Hu6jvrTyF8Oe8iBTXvSgb1jyXDZs8r9fMPU3eCjuuw4O9jzo+PJA7yLxDbHM9ARO6vPDxULzADk48LB+YusgNOz0CPEo8PmeOO+STMzyJyoG8eGAHu+RDsbuVXp67/KQPPKxpprzHGSi8TMtWvAAlKzwRdjm894vgvEV1h7yLIDW8TTBHu8EFLL0v/oG8E6bOPQhDI7yZq8o8GpQ2vOPfMDzcKwQ8RM/Yu/NcTD17S2k7nv27PL0TNbxCUiU9FePEPIcaNTtmAV+9noQuO6vA6L0KOcA8IeylvYFAbLwExFS7QAo1vNftNLpkj1Y7MFAzPPT3gj0yGge9EzWpvMf4ObvNkV087VNYvIMZXb0FMo88qoe/PAZS2rxZEf27KE06vREPtT2AS0O8nolBvMLmUbu85Mi9LzGXvSsOYzxnj+m5wltbPKZzpTw3KFu9Gu5mPOfxWD0VDBi8zumyPPGGEb1Azk89Ie0Pu9kXo70RKYe9b/zzu/8J9Ly1Wok9F7NuvP1dcL16QFg7QnmkO48oFz0YN7e9NeHbu5XdNjx2zy28u0MfPT5RNjtUN9O8Q2ZdPANpZT1Wt5i8W+j/vJMo7b0GAW885/Z3PHCWxjyxOua8gRSaPE/hBTmZ96c6ueIlvN85KjzJEbe8ByCvvJnZfjzRNHk8uenFvN40DDw31Gs8IUDUPJvxhbyFAXg82BzauoUmLj0Gd7g8kE0xulaV2zy9b7W8v04YPE3hjrv9JTi8xCGHvYIkwDyqOMK81fCKvVC7ejzAUsa8P7anPI9BBDyuhKS8yEUsPTAFkDxQSQg8ocl2u6FngbrrGcK8I9qgO63Cc70mtcC9hMNevIi4b7yR5Xs5Ud6ePQW7Gb1geUM9M9FHu9KTGbyTBhI87zImvCuyH7zp0ew8V2u0O4MZSD0j01E9Ie/nPMaGHL0kkpY9CenuOgP/PrzOeeq8cSFhvSFjkDuCtAG8q/BVPEll671aRyy8QO//PPHlZ7yRBjI6mzc+vJsB3TuWMBQ8v2VNO/OIp7uC52w7Y7QMPIv+ubx6mHy9Uzw3vTXdhzwyd1c8pAYcvF6jED2ISU09JADPPTXwerzNYne8yOg7PNWUabz7fZ68Coi4u/m/vr1g16C9ZCIxPTHXdTqGVJY9K8P6vJZaXzzv8au8e60yO3nKmDwGcSW8hdtSu8XspjyL1hA8zNJzO8zIO70dbU48boUxO6eLYj0gBaS7BgxRvJr9Sr1zkV+7VnnkOoGQ/z0zsvk8RWhqPRgTwzzD4n47tCG7vOW6kDzVFW+711BEu1XPHTzpMB48jlC0O0Q9QL0HQh+9F68/PDlCUTrq0Rk9BOlcPDVGSTlcD5M65vBtPUN9WbylXBW71M9bPTarJLy3Gj29dCQ6O6HM/zxL+Jc7zwBMPHfoDLyuDFm9BSq3vZYYAzzD6Ty9G3d4vQUeZjwOQcU7q9prPOW7drxRZum9LPa2PVwMV71Q7f48xgazPTbgWbtVtUi9U2STPUTrFDu2b8y85fQLu4HYWbxZLy08kjPOvDWOHrqIIBe7yHT+PPdYnz0OsPk9MhlBPTy8gTyEY2c6i28zvDNe5DxvdrG6d2hmvTAiyzx8Rnu8uDzhPNTip71HbpQ70iC3vYdkVLu+KRo8ulBVvEFU5TiAHt+8A3NlvTTv5zx6Zre8NQdPPEEpfTwnxIm8t/Btu8F737xHNc+87aqvu/KBwrxB1GC8/lozO8tExbtIGp89B9qKvAXdJL0IHvq9sosUPAnC4DzYV4c9MJQVPKqAlTv5mQq8Cpk/PUjHjbvlQE89gVR3PVpKvjyWy+K8iLXBu7wBtL1hXr+8gtN8PN/fAzwGfoA8yaOxvVNcVD07cTA9E5asvQwdzTxsnZk8f/tuPKLqa7vep7q9BMA0PYx6DrzELSE8Vl19PD+xNTzigXw6cHSpvVq6WDv3PI47XEvhvRtgkzzvg7m8Oiw1vB9e8rvyv8e7QfV/vFUaoTyIR6q86vlAvJ1lbrvY3RU8htQ9O27uhjyXRwc9bsOmPLtgAb1o7mO7jaHPPCXx5r0pP2S728k3vKnMATxucJk9NBqRPAkFsLyaSD28Q0VQvGNatDzcQuU8wqvWvLjoEjy7zWc9HO+nPFktxrzL9kS7zQPuPQpCgzzS0607xHXfPIxPiL1N+CS7jVBrO8pwobvdYbg6O+bRPU9+wryNOco8jawqPAskhTwQdRG9OWwvu9qyeLzAlIa7Ek2jPQp797wDyGG75v20u61D9z0pmIs7NuDZvMlwiTx22iw9KCrsu5UYr7zVhqc9QyqavOhaZbyJzJO8A9RuPQxpC7svApE9Lz8uvJFFl7yf18M88QXUvLkhgju20Ua84Mp5PIXtv7sJd3Q89ZZAPaOoFb0EvUI87OUuPCd3obzCM/88v4XmvRUpxbtBWCo89JBlPU8N5LyRyWW8Iqt/vWqLzj0R8P+9ltKdPO2W5rvc/Hg8qlLyvQ+5sQ=="
+ "query: amber" "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"
+ "query: amber -co" "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"
+ "query: amber -cobalt" "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"
+ "query: amber and cobalt" "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"
+ "query: amber co" "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"
+ "query: amber cobalt" "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"
+ "query: amber not cobalt" "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"
+ "query: amber or cobalt" "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"
+ "query: and" "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"
+ "query: cats dogs" "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"
+ "query: customers" "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"
+ "query: foo%bar" "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"
+ "query: hat" "PdaLm70tQQk7AwwFPPyx7z0ahVm89735veF1GrzF9Hc8LiT8vV3O1zxO3JK8dqEjvAqE4Tt0egK8dJGIu+on2j0AU+i9FrU3PYtW3L1mrjS8PUZPPXpdRTuHrYC8E4shu1P1CDy4/Dk8in97u0fxfr29wtk7zHIKPLfqzL1FBr09CJ1TvbJQSzzZIGK8g6H0PVpE5buRY4y9pMG8PJZF172EijM8zdtyPX4SVD0uT+K8yFtKu8GQiL0NE4k8rCnuu2ltSD0MD+C80eQRPIjgDT2vyEA9fXQZPccqLbmbTj+9FjBnvUxK5ryF5+K86lvWvQiJtbyaeUm8DWLpPHZwczyS9zM9xkoMPR2AQD1FToW8v4ljvO4gEzxBFGi8eAuPvZz5lT1fjxa9YfafvRNxOD1J+rc8mZIavbY+UzqqZRs99XrWvKsK9TyVnxc8E1DivAq6HL0jb7y9LJgMPQ4bpDyKZKo8ifLROjR1rLy51ow9hJvuvQN03DyYxz+85/GMPE0hILxUwd48iX6GOoe/pLwfGcQ9w7tLvalMBT1qRn49DP9XvV43hz25xvy8lJYGPUNuqjwzQyq9FfH1PCPIRL3RNWM9KNtrO2U8xDyQ/Ue9EZXzO8LZ3L0IKvI88kS5PCz2Dj2DHZs9JbpBPL/3bTxavX28pPx4vQMfUz0Lv2I9kRsQvajlDruOvGy8K4Ywva7CP7zsglY8/QH3vYNmHr0DC9G6Tm3COooR/D1ea+M8xHFyPWHW1r3sgIY7r+dcPN9rMDxZAVc87pCUPKmJ7j0MnHy9YgINPVER5b2RHU282783vYGNWz0vVj+8ddAxPPdPiz0EJzU9unOuvFyw9bxeLVO8twtAu5GnFr1KLbG9GkbYvYE+g7zpp7m9dVBuO52eETw0zt07miOQvPTObj2sJTI87XDUPNnzlrxowE69W9uhPQ5lErvFwLQ8j865vNjDtrzD1P670YetPAAyz70nVP88DnSQPVOtC7zPgI+6ZbeFPSdPeLtl9km8bzewvROoV7181BQ7CVVpOwAhdj0gwog8qTeyvOgGhT1cqrG7RemFvIyL37zhrgi9Kk1BvJMOlLycgOm7hDkhPTUdXz0Szzg9AmafvLYjOLz3Bc093SQzPL1bmrzk0we76+EEvBuXcT07+5g8+NFGPSdmcTwUqKW8QkjKvHCgrzl8OO48rNImvFtiNjy3FuG789ENO0y3nbyLRTK9EyzyPJh4fL030rG9YPhBPILNSjxw3/i8u772vVE3sLxXCy276m41vTPqazyauBY9Gf7bvNs9Gb1mq8I9Fzv2PE8YAr04xts8d6SpO4Hjtz0D1Zm88r70PAOVpLyeAye8WvxdPSJ0OrxhhY49Ymv2PM3VZ7rXbT49ITTZPUAtLzxoExQ8ziiOvBAEULyY30E8E2R2PQhDBbu1J7g8YnRjPLR+aLzDdE29Xi+evKsjvby0iDs8+hSKvDccP7wxSCG8dzpiPKNphLztz+C7rro+vPTO7j1BGte8aXgvPNUrdrwqM5O8PVDEPKrusLw/zbs5laBOvLn5kDyGzjy8ncUPPBWywD0C9HK6YmYyuZqlQby8fOU8IaqlPFLW0TyuCua8KZnAOb1e4zwnZJm8KZmLPOTGxDzTJYe8dFPoO8rHZbwy0Py9WWtaO140rjwjCRw8VPYaPBeBHj0a3aI5mOeKuuOhRjwGFyw7wwvPvQHw/zxUOe+8G46LuaZSzbukfX+9HNsZPH+hrryek3i78/qQumvluTrOvHI7HWTpPDpSZD0wwUg9GoQUvQruDT0XfAk6/I9evItq7zz9oPq8srVWPSoOnr0mp4M7e7civA8APryau6O8PtPrvKYYJbwoqbq7mNOaPCDs5Lmiqn09AyttO58HrjspWnY8/+TavB439rx95VY8y0P5vGMQAjymz2y818DnvY7/Mjwn4tK6+7nHvUKzyzysqHK9VjtqOqFyCjw9O0q8mQR3vBoo1D1UtBI8LICcvOv3fTwd7YQ9XF4wvGNlDzuUnJq9EO3/uRIwC70DaWO8XHdTPIaE/jzauvM9GKkRvE+jmLtWed68nNZSPD/5orumg4I8hxpAvVsLlz1gdYO9puuXvJk4uDzr5eG6xRE1PQMeLz0Zbwk85rRiuyWKhjr23v08bXJ8vMLqOzxy2DG61L4kPOvF8TwYvqy8v3ymPP745zytONo8Cv4xvP9qxzx9HOy9RKYEvR5dBr0nR5o8i44HvISJDr0DDc+8/By+vY0SJrvSC/Q9P700vR7XEjvmPjo87jv8O8bS8Dw9vHI9KlZNummADryAjUE8ZgoUPBnR2T2wcGe878Qzu4vj1j0HQ/I8gwdVvP4KFryduIS7tWdkvMR4JbtZKQq8jEhIPRXft7wExIa9CF/NOtRfCryD2Po9ABpuPSz7mTvR9ek8mWbrPB0kpj0bV0e6pPXVO594TTzhbMg9HK3cvZJIOrzcjQu8RO8LPRZRST1V+MI8j79jvBqcaz0LbAa9Ip6sO3pLfDyQwc09Vn9QPQRV+b1cNFc9LSPHvTOtsL1URU08gehvPCPfJ7zXlTM8U6Geu2sxzrsviSO5MDPcuwVHHrt2TKO86FSsOvK4eTxoM1M8svmFumQ6PzvH94i7SxKKvKYkmD0rzmI7g5BwOnsaQjyzaRI8WKQevCPA0T2wzgK8wM8GPMX4gbxLlD48r7k8vG1mTr0liUW8nNwHPVtisbzaTO87lLsIvHwTurr7igs9NQNmPDc5ljwR9Oi9fWEaPEDgADupafs8+E0/uvKapj1LrOW8j3+YO3ASDz1EcEI8uMpDPByn6LyTE3S8h8PnvMR2nr0RqF682Ee/O5HvwTt1uhS8gFHEvFCChzwe14y6ckFSvQQqPDt1BIO8rF5GvTAuMbwMucK7DhR0PJ+sBLysnY08sSjuu+pIwDvKvwI9FcJIPK/z9TrzEJC9gh+mOu91Lz04HSy7uBBdPNOXgb0AJWM8vLssu9Y9GrxOeEe76opsPKhQt7uPs1+7qVqUvNYLH7gPMt26zVwevBGT/DxjBRM88HtPO/i7CLyVTXU8jEtiPNojEj0rmHu9ZKncu+rITTyeyuy8SIv6vPa6C70lcqM8QRDlvX51c71Pwxi9KPBsPV2HcjuDS0o8sROFOsbpqLzPHIs8EtM3vaqyAT2YJAo8tOfjO+aDZrz0gvM9ELrEu/AkSrsORaC6ynkcPNNUlDuwary8sW2vPDVVlj0BuH47gUakvFrEbzwo0648kGKsvIBXgbwUvRg9ah/zuyAJ3rqlzhW9OGNkvUGYNzxQXyU68SLrvA/FzLxFSrM9KHVkPBH3JrnsF4G8zN06u2vHET1/5yi7khjdO4R8QTz2y8u6GcfRvapgFzxiiAm884AbPFjdtrwf0ru5aaZuvLIrNjuHdSY77H4LPOLpVLrD1uA8mZLkvBEIpDyyjyQ9SjwVuoS0wLz01sI9oLwdPYX2Rz0DLwi9gFe/vTxBWDv+td88yG8DvG2tWzzT0k08EVzUPFKWtDykFAO7SjfTO9oJE7xptrA85MSEu8Hlnr0TTIG9AP3TPL4QIrwUS4+8ppkvvJ8vnD0lByU9HoDqvH5eTTz+UgY8XVCAPJDc5L0OL2G9MU4OOzY/Tj05Nvy7ym9qPCJA87u/H5Y6VG4mPJh8db0ISLy6uhk5vHHtmj0ORBQ8JGnPvSFy3L0iXdi9M2mbuanpYz1GDie81oMTvSBzUjzZbv29OZGTvUEzO7ybqy+85OH0O8tL1jyPkrE8mWAmvQbXPz0dLL67gT5jPJpErbyZ23C8DAMqPOqlAb0HQ7c70lZ7vLW4cTyin6o5dFV2PQ+bET06FUM9sfM6OyKm6r1czYe8f5s9vPfds7xE5oE819bkvJYqILwpuV+8rerlvJ6n2rydqUk9NG/IPBfc4b02CMk8yM0yu2puIDwYeY88ooHGu+0NUr12GiO8Yc4RPSBvQL0vPCs7YK2JvMevxbxfpo67XzksPNnkjDybDF68vgjzPSBUBL0Bpwc8gRksvLy7bTtJN2K9FG9fvLeoG7xTW2W8Da0pO4kdwjxi2ie9HyunPFx9kbvEtWg6+rN8PHt8Cr0EDqU8+HpivTvxwzy7hdc9DOqQvRpgLL0Ye2y8ABZvPTxh+7qc3SS9viw7u4EtqLw4nwe6upvpPYHgkTt8Mp49b+lCvNMLvrrWPgg6vNtKus1xtzxLKti8+Uf3vTf19Lx4M5u75ueSO7tHLb2DBDO6ia5pOgvBuTvR2qi82eysPNvC9jx68gy8p/GaPIE1cD0b3ay9ZlVxPBndVLySDfK8hf1XPQWTErzhxP08VdG5O9x6LLwln6a8gvn5O65/s7vk/VU8pTMUPKx3vL0c/II8mdlfPQwcpbx6bQg8NZQNPWVRELxXDTm8k75nO8MntrqKBsc8uR6qPBSimDwakPs8t+vtPACn5LsePMa6hA6/vOjjTrzqQ0u8YCTIPJjTfD0Jdhg8rMATuz0WDb0ECBs877IGunu83b0c1bQ8vKRmvMe7yjy4M9+71qkvvEZuJTztRF88OIyIPM8bczzlrvk7v8bgO4NToD0DHvW9GsnPPDkcq72aNgU7240KvEiEbDxkOQ29IfiOO/+IOLt1H4O8+VUMPK19tLxGmny8PZ2VvMVb57wBrKW8CZKzuKxKUry2OSk85lPEPPPOEryKHxs7xfXZPApz9L0EsrY8XT2pO7SAhbxHJZe9Lt0WPJrPOr0X/h28sOk4u6aumzsarT09kmgivQaqMDy2nz87CP8WPG+5dbuWg0K6lzQIuTFf+j1GWas8wiOIvDtPezta+Rw8C1AJvOy0PD0Apc28PnZKPCcOZjxsDly87ZAAPMHVRjpLjNo84yypO7+X57zHKGc8q+5yO22gqLvQslQ8sAxFu/MR/DuXQSo9QDLyvZvjPLwtIhA8730iPJkE47ys07u8ls+PPTVZFD02z0o8ET3rvSm+lzyWRl6482KkPBZZNLyIwzC9J6ndPJWPFL0LQG888A3JvI7L/jz8JyU7jHYKvQ8fjTyhfIw8hOgXuzABlDss9WK9EXFDvLW6rLzHSA+8jjFXvJnuBbt1+n28seS/PXJNCjyQ8Vm8/jBcPO9hp7yiULm6p1qoO+ixmbqcmio8YaCXPNEju7uO0f289078O9HfULxSdCa7qlIKvZi4vTypjyo6/HyevOfFAbyREG49gR1luyQnTD1FR4+72p5uPAG8crjqBUa8KxevvVOlxD0NcXo7/yilOsp+RDwzeRc7GKm8u+WizDqFChg9C2rAOqC6Gj0YYpq8zYHpPMSU2zyCft67rcZ2PKJ0qbuIxMM8l5h3vHYUfDxRX2K8s2AOPKs2uDz9W888ympzvQ+6oz1nX/Y85GN/vQYWgb09vqS8+XWwvAGyoDyelpY83GOiPItmAbqHTGm9XvgVPL3dlzyeOgq9RyZPPUJoxA=="
+ "query: hat cher" "PKlZYb28dRM8L9roPSukgjy5yZe9KPnpvIF26r0Trgo9Iz/lvOG8Hz01Mq29GlfxvR+lLr0zZGe9XvuPvIBzCrxUQKe9T0wzPMUyTjxWAbe8JIsrPMfWXD09TWK9TKB4O2DUaT1/ZBi78SPePQZtnb25Gsw8kUEFvOjcST0W72Y9RtjxvU9HXzw6SRy9BEiNPPeaCDy1U+i9D1NvPLpAN7ysj3g8gEXGPMwLWD0WDCi84u9NvP0ViDteu6M86vmZOw9OlbzZ16G9neWOPP07gD0WnPs8MXwgPX+6qLxcb2G9HSXdvW8QsDyxWWW7cjJhvIgllb1EiDA9J+I0vDQlO7yPQXY9iJFQvK+Btj0bbTM82rPjvQu3D70Rhb09HwNQulEbRD0pAWs8DU1VvK3YmrppMJm9AY5pvUSYHrzYl0M+DdQcvWDZVLyYXiE8pbLuPPz4M7uXg8+9NSuxPMqCLT0OwOi9hO++PKvR5zzGDlm8qLwuPC5+qjz8Fxw9fCnnvQ2/8r1A9+K75O3FPE3gOb1IbQC8uYlHvbbguT2rH/g9MlFPvZ7DTD1f37O7VGerPZCP1D1cRNy9KkT9O5zSe722UnU83HdZPAe9vz2H7xM8MdMwPUWG+TwA+s+7+bwdvAz3rj03jqU9g2zzvKpEOT1QT8K7i8PtvVpZmrzlw3s8xe7fvZRvKr2UwQI7CtcavVhatL2PFLk9SjwXvEgDnL2XvS29AwqIPWevojo8s+I8bgMDPTUtlr2jjVG8rdV+PKY5bzr+DQk9ZpXnPW7VGzpUzM29UhqFPYKJvL1G7569sGX5vYNYNjszBR69bbdtvKe7iTqwL8w7ShP1vQfuF71Wo5e9MzbLPEBeHb2iioa8/Tc6vWO0KLyDvWy9R5PvPKzVR7tI4/U8xSNovOOXe7yKxIw9EKPIPJCgEbwAi+m9i4ekPMyhz7zqn/A9owFsPOxcQLzjOLq863brvbRBpb21dAA8rBHMPQcVb7wD6EY9L6ORPTRuZ70DDrO9FM6ivLbm7b1eDDq8DRkyPSyrsT0tKkc7kuXpvNMAZjxnNua7QAChvP4lUr08BlG8lD2kvUBmrz2GAdc9DzIAPYwx9TzRgvq9JanEvKHdP7zep6s9XFfNPYGpzryM01C9ShEavJ9/Vj1llBY90Ax2vTGEUrnylXq9Ekf7vMRHJLoQpuo8iqX2vS+eXLzeObw9jV18vUnXj700RqI7zKm2vMR0Yr0/9kK9PUgrvOu+Xj0ntRa9YoazPJ/J/LyPui88gu+4vTXVoD1LLKw9jlsLvGwL+rvXPQY8a6nnPLUjmzzJhn47yOz5ux6+9z1hs+k7DlS3PSVqqjzcnuY8LpaxPKLQqrxOmX660rafPSF6PbwxGLc9DtofPRvftz0Y8Ys7XcVKvKqXSbuVpTc8lkmMPZ4Mwbq6ZVs8zzMkvDef470cpR68RV8lvL7ggr2I1Pu9VXRju7YWKjy1rfe7sXJyPSQr5juD1wo8JNyvvLWwqTyxz727aMO6PTfG0LwNCpe7m/EOPMK5fjvAEeo8CI+/vRQzPDy1q9S8H8bCPM0WSj0FRZ07t4mLuon8Rb0Y6qm8p6BFuzls4z0tdmu74lCBvXVaDDvkZe+9CvZvu8CFLTy7MIq8s3bdPC7k77zUKre86t3YPDOeaDxAHpW8Ch0XPNYscTv22t88TamWPCg3YjuxVTu8QJPVvFxZmDq0yyc8pkcavKg53ruhQXI8QnwkPAziKzvYuRG7E9zIPJJwmbu1+1q8Q5CfO8NA+zyb/rK73VxVvQvwGzyWnvS7P64qvMxbtbvJ6Ra8hx7tPXYKRLy5PVA8N84lvGbfvDvsLFc8rka2vOA9arzNtYu8Cf7YOjlJ9buKZiK6xtmOvUM0EzwMqeQ7E8cqvTzizDzpd408w90fPS0oPTvWc5e8V3q0vQ8PDby+0528Ftq5vJjAqbtIKVK9UyPjO6u7uTuwCWM8Nm3nPKBSmT0LCNa7L/FQvKesYLuVdqU80rl3PFcaaL1OudW7nI6KuhuXC7y3oy48p267PVhEaD0X7fM8ZcacPVBa5jxNDMC9FXXPvBvfkDs6h/48povDvMI+GTyD1cK9BK1OPBCSE7qemHG8uayFPIKkRD0cHL08UN+UPHt23b0Tr508F/BBvVkZzrvzyzQ9T1yjPPdA3zv8Dkq8k/WVPItRTTxGkOs9L56ZvMly6DyNpUs7nSozvWKAiL0kOuq8kV2DvNG3kbwUQ6u9RBTXvTTKFrrv3PA8DdFPuqWbd7vXdus9UHH3u5lAPzyBcfc8y1iXvEcOZ7zNcuQ84Li0PKqMij1PK6G8X15MPEFkrjxsFxo82IX/vSdeQzmiyOm9RUV6u4K5JLyRv7G7JumOO1EpIbyU5k88fQUwvOohNzyQ0Gw9UajNPOli2DxydGg7mE5hPANMLDsrBFy9LcihOz8Z2zwABlE8eBXXvXgBojzGYlm8tVSxPQPOIz0+8+48b2LCPHeG7LwfaBG83qcrvAlnaTwm0Pg9BtYCO8UgZzklCam7kxogvIZkhbx706M8NshJvCdXJbvbanm7qHdDPR9NAzrpDBo7AsPQPOVEPTwEh/+73by6vMfe3zq6ou68awa9vLHSK7vp4A29PI1RvUx8Qj1BJrI83cg8vOV1kzyEmdq6gGvhO82BKz1a5H29ZHM6PJ0NWL0XqC48SxjyPQnYvr1QT+K8SWrGPTrWvTu45gE8z7cgvDFHMzyXQUQ9Sf5PvDwnsbw4mwa8igVEvCeCaTxmPJc8JZxrPMPmdDwYgV68+/sCO/uDJD1RidY8f1vDvI1UGzmzqOm8H9vKO60Ff7zlYZK8nRp2u/OnXT2Csea9AWI1vT5cu7wLIeE9C+WhvSV31DtfoDu8FInOPCDIXLq7ZPK8A+XGuhBxQrwQ15Y8nL+WvE7uyDmEnww8aNPSPMMWSzwOTC26gNMQvJ4f3T0MVbE8bw9uPK+n0b0kLJC7UF8pPBkM/jytjhc8lml1PUJxtrylRUq9C82qPBOLBDxTHo47xdCEvJZhwb0sAtM7v/mgPEL/fLz9UnA9F3WePFnWzTwYSmS8oGmjuiO/LLsdtL28ZOT+vMw9vbzvRfQ8o88hvZ2a8r0ibNa8vIK3PNEQGjxLBgu8dlZZvODhR714f+u8JJSCvYSbhj0WK9S8pUmjPJ+6trys0/E6jOv4vAi0aL0vUuW9N3tYPOHIprwR5HC89E2GPXrHLjybJwI9FAiLvRO18zy8mHO8uGdZvC0GRz0b0048vQ+0PCT3RjuVYca9OTGfvcqPvT0s5Y48PjIBvEFTvrrwLo07JNrGu4Y99jwcS4k8SdBKPRuFhT1DRUg7VmmOPCN3JT2TnrI8StXQvXEZvrwEZtg7LRhgPEiEUjz1tUa80UJSvCiZJTzDI8k8fLCOPQ5DSzwza7E9BDEEO/N9lzw8g+88FyVfPFjclbwW7J49XAtMPVEn3zyDQ+q9t/uFvR+j/r0OHjW75hSyvFm5Gzy0mOa8NqSzPSuNHjwYzic82fv+vN5ZD7zNHDo8pJ6NPPKfu7wezTO7+hqWu40XE7zai+28puk0N6yR+DuHv8u8qev8u7iZCjylUjc7tkysPQX4yL0IKZa88zn3vQ6WNDzPIV29EvfHPVh0C70zJnA72QlAPDiZ370L4W08jSwYPMuxyzxcb4w8pGcRvOosT70OB2Q9FMQ5ukuejD16iiE8Gc/YvUhiOLwSljA8onGivYY1VzyZPVu84JtLPCgQt71hQq48qcdruvJKWzxY8Do9H/zyvFqdibzdRn48ifB5O62RXbyZLb08SdzFuxX3abyVk8O9DaluPLJ8Yzxq5l488zzLO6VE4DwOdwk8YAP/vNMHWjrgGEY8odp3OWd5oD0/7r28eQYPPGMfer0RWOk6l0KePFQR3r1XaOQ8eLutvMRkh7yVJXq8RtgqvMmY8LzT6E88b1rTPOZ5Ub0JH/K6u47MO+GD3Dw25IM8A5I8vADO+D0MSbC8hCtOPPKke7yhjkM8lg1PvOTNNL1fFfy9SzXHPHFpGzyWkXQ9CUo4PL9zpLuZY4W84Hl4PQSBfbv/7dI8/aHVuzg46rxaHd08/7CovDeoHD0a1p49P1MrvKVFbb0xlMs8FeH4PQd/e7z44qC9FzHsu4sL27vJyva8u98lPXAFBTw0IBM9aYxsvHefOzyWEGc8kTvNPSieMj0mMBe9VyjCvTa14zxIgCq6IWrvPRgLkb0aq0a8pXldPFEJIjzcsVU8xbbYPTpHgTyuRzm9GRTFPQhCRTykIyu801tzPFgM9LmnG3y8x3tsPSorFbyQkqY8vcN1PCh5c7wVrB+9USt4O88iyjsGBUc8pWv1OtFETzw55NY71ZzVPNpSnr0dqO89gt4MPREXsLz0d9Q8TsqMvQPZszwuJeu8wPSsu5Ocsrw9LD082lUqPG6uKDu7S888Ir0MvQHc8r0PQ2W66p0TO2WBnz0wEiw8E4oGPFhajjwklPc82HZKPDU+mjuiMio7ozR1uzLBEz1gOhO7gYnfPIyvo7qBT++8ePp0uYDDHzuwPqG8YiJ0vGYWzz1HLxO8+NTFPCNBc7uCico9DHdVPJ3zKTz77N+8mXHmPAuW/b2ILaO8pkh6PORTXD0LH/Q8H39uvDbMazzRxjm87GTIPJbOGDxT/KE9BJMXPDNc+Ly4EJO8gTqSPRS0ELyOSnK67aGovGBipLyoQmy9TvO3vANJYzxmzd+8AdSDvOw62LyDTMU9FCWPvNyHobwCdGA8EPbVvBWNLLo/jJa8X9qdvRmEpjx8Nba8FZPvvNFiDbwt/lY8VL0KOBiA/T0W/E68zdEoPHPcrbtJvUY8y4bLPSdwNjyDk/I9CLs6PV8my70cXZM8pg//PMokIzyNG6y8myJUu0lfm70aGZ08sbXqvZoo0LuKxJc9AqMLOysQp70Becm7QC5/PBaoJz1bw848xGt5vJ/WtbwmVbI9ZUxlPC6KZ7v2Vr27j4xqPQB9YLyMdx49GV0BPJFOPTzRM0I8rloGvSJuZjyqQJY9e5YXOx6GXTscbIK8aI+svQXn1TrqYWk8RTrKPG19uryCfmE5kC/kPRfTDj1YAva9P/pXOnfXlrug9+E8x/gtOt/ekj1bu4g8T32tvCmjbrywn0K9P80zPQYY0rxaaL46FlJvvIso5rnBaIg8ffkivJ95Sr0JzvU9iM05PJe6aT1BAoK8YIhwvHmyfTwYl0Q8Ko8QO+XP/z2HFUe8ktpQvCM6kzusDrI8zMv/vEXOvjwM7oo9HeP3O7wtkDjj4Oi9JhqlvCc957wXlmc9BfraPTGRPb0XRNE9Q3pRPJeJ/LkJ7ym9BDAlPW3vYbssvB67tfScvGnEHDq+Y5I9SdbCvS1UUTt06iu7DPTOvP5Iljw4bSs8GlB2O/eNLryZTOm81v4TuyKwMDzsRiS9VwLnPSjXXw=="
+ "query: or" "PTxNBTrl7p87IKwLvLjyWLx7XwY7sWEmvXbHvzvtwqQ9G8/xvaIbTDzRGnE8fsQ/PYaAuL0TAye7gL5cOzdRG7sllra65NOhPNOCLr086a69pHCSOQIjXT1i7Du7KkcHvV9trD03ac67thhavBGhSb3TUmI7FgZjvX18U70NLfc80pWdvXaswT0Bj2Y9IRObPRAqnLz5wOq+E/EuvLiLSTwUv1Y8G0w7PJAUjD0f6uW9kc0KOvKG3z0B7QU9XI6YPVXFmT2Z7Ly9mPzEvIrPjD1/ihu8ZqaRuwzO/D0ZUEG9CaHIvKaZ17lkeVY8C3ycPIikLLy0gxg7+z3mO+vSSb1jYYY9uGIBPKviCzzvuww9SmyWO6b3GbyUIEA892UDvWbqa71I65q6Hg4TvVB11bpxeuG9OoWZvAF3zj0hJH49m+0jO/qGdrw32VW9afXVPTWfDTzmGt69FJ/8vH1T3D1aAPE9F1lbvJNQ0r2GP9g8x/NpvWuGvbwSjc68oey4OyIYezy36BG6yqykO+Ic0L0LTXQ7DD+nvYOIkzsBoH681RDHvYUtd7z/ICS8WWK1vO8RKLwL71y9gSiPOry26bsYmaW6b3U9PMh23bwy2CG9qFQBPQ51Lr15xnW9a64mPKaOfT2Gn0I9ZMWaPbDl1Lze7ug83cprPDJ/HbsUFio9AuCjvYfMRjolFfq9nspHvTcI/r0mDsK7V3/GvKqGZDuwIJi9xvV6vWAv6z1VH2s9ehvsvJSu971p73g8MX1UPTIJ3jvy9XU87+HavST6wzxqf9u82iOxvQDwpr3cx9g9MncHuoOV2bzC5Fk8006xvURtmjwgpSc8G4T2vEoVsrzZDB68q7YlPRuN5LzU4zU8/GtKugOCKbyW/ym9Yz7CvUDrETzkMl27jf5JvaqFzbwEjx69KVJPPUyQ27wGjtm9Mrd2vLDBRrwaDDk7/jpFvNx3+r1jTrc8zWIqvIutX7rC5gM8zTN9PRcyTj1kHCk9UdKRPRjZTT0BYp29OI8WvM17BLzYj/c8fHM7vVB9DLu/riI78PTivSIRhT1i6EK9Tb79vHA/rT09GJa9aTYqvZvjlDqYRPk9K/2kPJ4EZj0vZPc6zqcBvHwiYrwd/RM9RsX+u4cQrb2gBxK7uv3/OrhULb1H7UQ85rs4PQuWoTz7KAW8VGiGvShbeTyU7Pc8Sb4vvTGNuD3BsTO9iqSMO2ErGr0tbN481suIPIpINj0OSBc8bJYpPImpIr0idKK7jzpHPRZSezqO5X+8l0dmu+EgJzyfXVE3/bKWu+a99L0Ssxo9X1YrPF16TbnGe1K8Bl01PKjtzT1cngK9C8PfPNqKZDy3v0o8hpXXPaWAgrxBWm48qp/3vTRFgrzdCnE9D0xAPCfUor0D+Z49DMzeu1FXbTq8yMk7IYwPPUQIhjxzt0Q70kk5POPqXryyR/q8o2TLvYPXyLxcChA86s28uxxkHruur2+8MD9qPKHmcLx6J306pxUFPL/73T0PywG8yC5+OqCQ1DwQSFc9S4nevHqaPLx83WQ8QoCpt9VDmjzpho68TszSPG6tZjzZtJC862tXOkPOZ71Yzie8IsygPN3CUjxc8jm8tAMZvIPuID0bZho9B1D/PAA0v71GaP28pNbavVQrW7uNY4w8MU69vHZQfL0nTKo8McE4PLq0obyJapY8QLQfPSit9zxQ6Um9OBK9u7q95Lw3LNK8tTizPGaGDToX2Bu8TUPru8/Acbw1F4U8NWDXvRnVg7y94eA9VmLfvFKbvDvbSWG7w+W7vB3jojz7kA+772FVvL/Kdzzs7bQ8u8WFPR+VTLy3DCk8l9MXvGRTzr0gxOK83wK1vJG6QrwSt9q9hrY0u48SRTy7SSs8qpifOlWCO7z8Jh88nd5EPG3Q2zxkCE888AIBPNakJjulBkq9N1fevXSGIbxQvys8kClQvET0ubzopxU9JiySPDuBLzwY0Ey9FFHVPO92zT0xn/Y7OZiLPQEMDDzFp6Y8UdF5PLwMVjzEELO8zJ39PA+fMLyPXNM8n3pCPCDCYj0ycuw9JRwKPA15fDtC1tm9DgY9PSx9qbxaTMU8+hxNu5yJLL0LIn6807eiPTJka70FhhU8wR1NPIfwXrx4Hog9LeQqPIdGXDuZEz49FPxLvUI0KDxFV5O67jPTO5GsGrzfH2M8TR48vNBRwLyjRo68Mb2QvSt9Mjyut1k7Iw9pvS4Ht7xqZV46jCxtvHXQGDq3KFm9HQ7xvX0MeT0LmhA7irW2vLbJmzwv+mw8LKgCvGqQKzvPaT89Ik8WPUsHFLqR+dq8ZM5NPWyQRD0SnBe8JMqFvKieNzyoPTs8HfdXvCBuB70tOWK8soa1u14Zgrutn64805c4PQpan71E7qy70gTiu8hyKbuGZUe7oQvovOK5Rr0IgQ+8R5EjO0liIDxXVgG8DBZHPSeFCz0auC89de1EvF7U9TyXoyA8ZE0nPU0eYz1FZd089B5PPAfhabzd4OC8jQcivJVeIzxISPI9ent4PZppgbxFr7k8sSyrvNsolDyL0jI8Yp9cu5XisrzfUno7k/JBuxYZabtM/aq7gD/LPC7+3LsfZJC8xbGWO44Fuz1g9s08P+/YvIcd1Dygwnk8jnbevA4fo7xFRE68U3FaOzjNzDx2DeQ89C+VvCpNVjz9icM7u9nXPR7LMLy7jPc8GBFPPDLsIbunA3M8nXIAuzOm170MCPG8wxfUOsjwsjyE6bS74Mv6PPQeBTyNH1a7cb2cPADXejxdz949AWw/O8B2iDyA5HU8pEMZO9WxHT0t3h49pGfFuzOALbyZnZO9LoNju4J7z7wVQCS94zbRPBbLzrzll848v1VOO0ohOLy55SQ873PUPRAvGTyShBS7+xZivNsryDzqWRi8I41APVz3aDxgj/y9LS7HPMgEmzu1HsK8gUsKPUc/oj0AMw69G/1cPKQidjxzB0Y85MYHPMyoSTxBIVO9CcRxvANsQjxmtvQ8tBeTPFeqmDuA+9u9RQm1vICAljwaH8e8408LvWjwkbvBeX08l4aTvJqEoDtHX2c7vu7iPN6fEz1Gwdg7jimEu/kzBD2O1iY7s2nfO6OsQrqBeUO6FijTvAa8mbxU+pC9QTOcPDSLgL0oWR68rmdIPNqavr2dHcq8qQGVvF10Mj0vqOe6auTnvLep2zxTGPM8AuxAPSvf5jx6uWu8ehQ3PL0XOTz+Nqy9C50HuhmdSTymNXE67LINPAuREb2qo7A7tWVHPK3Y7TyQ7DY83JcPvQb417s8VpC8kpTDvCC8nz0hWkO8jO+iPQn7xb2BRBk7VZwvO1R62r0ZLA48WOhauwgNmjuQOyi8BqboukKY+D1pzdW9EE3AvQMQ/TvoKHc78HDIO+Hn9Tz8w7E7IuM8PHkAjjtT1AS7q428vM7Y3DzFdaU88xfcO+h/ozxEBfM9V4HfPRMfRruZIRk9SCRBPMdktT0VV0S8SP1KvUhCA7yeNXE8urWzPI6VJT1nsug8stgDvGCl8LwECRY8Eh8ePQ//i7zWHNs7JYKVPKu4IbzKAGS7vrfqPJbDqL0StmM8xwnzvGShn7ydVjI9AfMrvT1/3j1a1WS88AMUPHytqLx8W/q9NFG7vQ6UuTyzc4q8Qm9fvEGcm70TtqA8ES/DPYgn+b1dxSg8vOOVulfwlTynv1w8AylqPBU1Kb2QbHO9aWigvExxhDzaKUa8gQC0vYxkmT2JxNi8wdKOu9TJnj0cvaW8OvjVvCdDUz1WNb08PaGQu5uFRT0cH0M7jkTwPEiNUT0cpfA8Srieu0mV6b0wr0i86049vPuAhbs2gd48njnVPYbyXbxCdTA8PAMMuPtIp71UhcS6/UyRPM43djqg//48KX0qvOkrAzz6bla8l1z/vJZ+zzwLrq89koCfO8EuJLzp8dI9he6kvQUdFLyH8Hy8mkvKPO/gOrybTm47oDbcvLzRxb1FdAy9PeQmvWle5LyusvO8ttN3ur/rNjyHEb07UAiHPRH5jDyx4sY8Y/iovJZH1LzRy7K8qH9rvI5ybLthvPY9sddIPTjzFbqboE48UaJdPCOfdjnzdQ08OYgcvJMLWrz5GEs8ISdovEnxlz0yUr88sTkTvCrwnzyPiOg9Jl+MPILQFbvYICG9R3fFvAYvVrvPLfo8c7NFPOqzkrwW1tO7gpvhu6w85bvsgWo7FyR1OnfiDj0gu829Vj/pvIy8C7qPckW8/kznPQEQaLzlJpM73r3nPRJMRz1HKra8/1hiuwX+Tjy814G8PiJ6PROcjzv6ube8AdqkvKBDF7y5vW49MRK7PTJZTzyJyqW8nl8JPTINcDsllzM8hj7gO5gUcb1MESC8d4G5u0f/HruZnXw7zXzdPE0d3Dy4Vko74gBOvN9RRDuIDdW8hMH4vG2n4D0pYMi6hes1uwhmA7w8lcy8q5K3PEKVrrykqyC9KvD6vVbd+7yXKmm9ZINbPR/pM7z71J674HA/u+PANrzaGfe8jcxAO70A6byw/Jc9CotiPNTP0bs0ick9GyrVPQHfQrsn7TQ8vsaPPPPGWz0OFwE8B8DCvNiGZjmHMlO9EUfBO9iwLLy25os9dyjyurW5ljxyvaC8uweTPCydJjwKHyq8LQTevVssxLy3wAW9Icduu1/XjzzrQyi8/9KdvTPsXzwpHxY67JFKPINZUDssTNC8LGyePJIIXb0vNkW7wGG2O5t4Vb0kda28arbjPKtyY70TobY9AohVO5urNTyaLGi8qAz7O2NNnDoQqkU8aEEJPBi7ZT0GvF88LJH1vBIKbr2I8Ym8SVZcO4gRurufkOO658HLvLQBLTyCMXe9HwJ9PMHcPDrM3fS9Ly79PTtBBbt7KdE9QSXkPD4wor0WBNg9FEDvPQqDg7y+S+a9EAxDvWFZ8T1DLuO8yjusvT4aOT1p0FK8GBQPPSkaRL05QCy8QXsCO4RKRby6Dfy7mkPNvMiV+7w+Wzo8WvE9O7e2/DyoKFU899uVPLLl8zsEhAM8rX65vUIK5TxEWp29DlNKPItAazztXFI9E99dPRp1UDwJoKW7281KO7aefTxSMN67TWAJvPdCNDxfU2Q8kCplPF/yyDylaXe6i44oPPXcYbkvPro9AZbFvDqMyLyX2TC3xq9qPJ035LjRA209EUbQO5gjqLuTKQq7XWu1vY3l6DxhquG8pYmNu/K4ULztYZk9bElaO+c5uTyS8MK8Gqr+PYCUNbvee9O9KZaTvb4fTTzk7ea8MWdXumKYe7zUSrU85kpwPEM2Pjm3ZOG7KS0lPA9furrvD4S9CMC2PY5oG7zH8Dw9SxadvJKPaz0knKk6JXi1PQQDnj0CKpU8O5tqPRdb5rsB1h88UP30vMG3JTzJDou8J/fEvAJbDLyRmuw89COovEwmpjrpCu072LncPTnAv7oWPfS8+F78PK5XSLw/F6I8owUhPIaIxw=="
+ "query: running gate" "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"
+ "query: the" "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"
+ "query: the widget" "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"
+ "query: zircon" "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"}}
diff --git a/test_resources/search/query_semantics.edn b/test_resources/search/query_semantics.edn
new file mode 100644
index 00000000000..16e0cc42a48
--- /dev/null
+++ b/test_resources/search/query_semantics.edn
@@ -0,0 +1,644 @@
+;; Isolated search scenarios shared by the in-place, app-db, and semantic tests.
+;; Hits are compared as sets, not ranks.
+;; A comparison inherits the scenario query and hits unless an engine gives an alternative {:query, :hits}.
+;; Comparisons belong here only when at least one engine uses a different query.
+;; `:correct` declares the intended results, which no engine need achieve.
+;; Semantic search returns the union of a keyword arm and a vector arm.
+;; The keyword arm gives the appdb/PostgreSQL results for every scenario here, but not for every query.
+;; With a language other than simple, appdb also indexes an unstemmed copy of the text and the semantic index
+;; does not, so a half-typed word such as "runni" finds "running" on appdb but not in the keyword arm.
+;; Both arms are recorded, but comparisons and statistics count only the vector arm.
+[{:id "multiword-defaults"
+ :focus "default multiword Boolean and cross-field matches"
+ :config "simple"
+ :query "amber cobalt"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}
+ :C {:name "amber cobalt"}
+ :D {:name "amber", :description "cobalt"}
+ :E {:name "indigo"}}
+ ;; In-place's OR favors recall; app-db's AND favors precision.
+ ;; Neither default is universally better without knowing the user's intent.
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:C :D]
+ :appdb-postgres [:C :D]
+ :semantic {:keyword [:C :D], :vector [:A :B :C :D]}}
+ :comparisons
+ [{:focus "OR across ordinary tokens"
+ :correct [:A :B :C :D]
+ :alternatives
+ {:appdb-h2 {:query "amber", :hits [:A :C :D]}
+ :appdb-postgres {:query "amber or cobalt", :hits [:A :B :C :D]}}}
+ {:focus "conjunction of substrings"
+ :correct [:C :D]
+ :alternatives
+ {:in-place {:query "amber", :hits [:A :C :D]}}}]}
+ {:id "infix-substring"
+ :focus "infix substring versus lexeme-start completion"
+ :config "simple"
+ :query "hat"
+ :docs {:A {:name "chatty"}
+ :B {:name "hatter"}
+ :C {:name "top hat"}
+ :D {:name "coat"}}
+ ;; Infix matching finds "hat" in "chatty"; lexeme-prefix matching avoids that likely false positive, but
+ ;; cannot serve arbitrary substring lookup.
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A :B :C]
+ :appdb-postgres [:B :C]
+ :semantic {:keyword [:B :C], :vector [:C]}}}
+ {:id "two-substrings-one-word"
+ :focus "H2 satisfies two required substrings inside one word"
+ :config "simple"
+ :query "hat cher"
+ :docs {:A {:name "hatchery"}
+ :B {:name "hatter"}
+ :C {:name "cherub"}
+ :D {:name "hat cher"}}
+ ;; H2 requires both substrings, not two separate words.
+ ;; In-place needs only one substring; PostgreSQL's lexemes match only the separate-word card.
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:A :D]
+ :appdb-postgres [:D]
+ :semantic {:keyword [:D], :vector [:D]}}}
+ {:id "last-word-prefix"
+ :focus "last-word prefix versus arbitrary substring"
+ :config "simple"
+ :query "amber co"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber corgi"}
+ :C {:name "amber taco"}
+ :D {:name "amber"}
+ :E {:name "co amber"}}
+ :expect {:in-place [:A :B :C :D :E]
+ :appdb-h2 [:A :B :C :E]
+ :appdb-postgres [:A :B :E]
+ :semantic {:keyword [:A :B :E], :vector [:A :B :C :D :E]}}}
+ {:id "nonfinal-prefix"
+ :focus "only the final PostgreSQL word is prefix-completed"
+ :config "simple"
+ :query "amb cobalt"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amb cobalt"}
+ :C {:name "amber macobalt"}
+ :D {:name "cobalt"}}
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:A :B :C]
+ :appdb-postgres [:B]
+ :semantic {:keyword [:B], :vector [:A :B :C :D]}}}
+ {:id "or-operator"
+ :focus "unquoted or operator versus literal substring"
+ :config "simple"
+ :query "amber or cobalt"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}
+ :C {:name "amber cobalt"}
+ :D {:name "amber or cobalt"}
+ :E {:name "orbit"}}
+ ;; PostgreSQL parses `or` as an operator; H2 searches for the literal substring, and in-place matches any
+ ;; word, including "or" in "orbit".
+ :expect {:in-place [:A :B :C :D :E]
+ :appdb-h2 [:D]
+ :appdb-postgres [:A :B :C :D]
+ :semantic {:keyword [:A :B :C :D], :vector [:A :B :C :D]}}
+ :comparisons
+ [{:focus "`or` must literally occur"
+ :correct [:D]
+ :alternatives
+ {:in-place {:query "or", :hits [:D :E]}
+ :appdb-postgres {:query "amber \"or\" cobalt", :hits [:D]}}}
+ {:focus "explicit alternation"
+ :correct [:A :B :C :D]
+ :alternatives
+ {:in-place {:query "amber cobalt", :hits [:A :B :C :D]}
+ :appdb-h2 {:query "amber", :hits [:A :C :D]}}}]}
+ {:id "negation"
+ :focus "leading hyphen negation"
+ :config "simple"
+ :query "amber -cobalt"
+ :docs {:A {:name "amber"}
+ :B {:name "amber cobalt"}
+ :C {:name "cobalt"}
+ :D {:name "amber -cobalt"}}
+ ;; Keyword negation excludes B, but it cannot veto the vector arm, which still retrieves it.
+ ;; This is a current-behavior contract, not approval.
+ :expect {:in-place [:A :B :D]
+ :appdb-h2 [:D]
+ :appdb-postgres [:A]
+ :semantic {:keyword [:A], :vector [:A :B :D]}}
+ :comparisons
+ [{:focus "exclusion"
+ :correct [:A]
+ :alternatives
+ {:in-place {:query "amber", :hits [:A :B :D]}
+ :appdb-h2 {:query "amber", :hits [:A :B :D]}}}]}
+ {:id "phrase-boundary"
+ :focus "ordered phrase, including the name/searchable-text boundary"
+ :config "simple"
+ :query "\"amber cobalt\""
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber bright cobalt"}
+ :C {:name "cobalt amber"}
+ :D {:name "\"amber cobalt\""}}
+ :expect {:in-place [:D]
+ :appdb-h2 [:D]
+ :appdb-postgres [:A :C :D]
+ :semantic {:keyword [:A :C :D], :vector [:A :B :C :D]}}
+ :comparisons
+ [{:focus "ordered phrase"
+ :correct [:A :D]
+ :alternatives
+ {:in-place {:query "amber cobalt", :hits [:A :B :C :D]}
+ :appdb-h2 {:query "amber cobalt", :hits [:A :B :C :D]}}}]}
+ {:id "and-literal"
+ :focus "unquoted and is discarded only by the tsquery parser"
+ :config "simple"
+ :query "amber and cobalt"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber and cobalt"}
+ :C {:name "amber and"}
+ :D {:name "cobalt"}
+ :E {:name "and"}
+ :F {:name "cobalt and amber"}}
+ :expect {:in-place [:A :B :C :D :E :F]
+ :appdb-h2 [:B :F]
+ :appdb-postgres [:A :B :F]
+ :semantic {:keyword [:A :B :F], :vector [:A :B :C :D :F]}}
+ :comparisons
+ ;; F defeats the phrase "amber and cobalt", which would otherwise conform only because no document orders
+ ;; the three words differently.
+ [{:focus "`and` is a required word"
+ :correct [:B :F]
+ :alternatives
+ {:appdb-postgres {:query "amber \"and\" cobalt", :hits [:B :F]}}}]}
+ {:id "english-stopword"
+ :focus "English stopword removal"
+ :config "english"
+ :query "the widget"
+ :docs {:A {:name "the widget"}
+ :B {:name "widget"}
+ :C {:name "the gadget"}}
+ ;; PostgreSQL's English dictionary drops "the".
+ ;; That generally helps a natural-language query, but not a search intended to find literal text.
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B :C]}}
+ :comparisons
+ ;; A stopword the user typed is probably intentional, e.g. a band name.
+ ;; The English dictionary strips "the" from indexed documents too, so no PostgreSQL query, quoted or not,
+ ;; can require it.
+ [{:focus "`the` is part of the intended match"
+ :correct [:A]
+ :alternatives
+ {:appdb-postgres {:query "\"the widget\"", :hits [:A :B]}}}]}
+ {:id "simple-stopword"
+ :focus "same documents/query without English stopword removal"
+ :config "simple"
+ :query "the widget"
+ :docs {:A {:name "the widget"}
+ :B {:name "widget"}
+ :C {:name "the gadget"}}
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A]
+ :appdb-postgres [:A]
+ :semantic {:keyword [:A], :vector [:A :B :C]}}}
+ {:id "english-stemming"
+ :focus "English stemming of a non-final word"
+ :config "english"
+ :query "running gate"
+ :docs {:A {:name "running gate"}
+ :B {:name "run gate"}
+ :C {:name "runner gate"}
+ :D {:name "running garden"}
+ :E {:name "run meadow"}}
+ ;; English stemming includes "run gate" for "running gate".
+ ;; This improves recall for inflections while broadening beyond exact-word matching.
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:A]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B :C :D]}}
+ :comparisons
+ [{:focus "English stemming"
+ :correct [:A :B]
+ :alternatives
+ {:in-place {:query "run gate", :hits [:A :B :C :D :E]}
+ :appdb-h2 {:query "run gate", :hits [:A :B :C]}}}]}
+ {:id "simple-no-stemming"
+ :focus "same documents/query with simple rather than English stemming"
+ :config "simple"
+ :query "running gate"
+ :docs {:A {:name "running gate"}
+ :B {:name "run gate"}
+ :C {:name "runner gate"}
+ :D {:name "running garden"}
+ :E {:name "run meadow"}}
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:A]
+ :appdb-postgres [:A]
+ :semantic {:keyword [:A], :vector [:A :B :C :D]}}}
+ {:id "not-literal"
+ :focus "not is an ordinary word, not a negation operator"
+ :config "simple"
+ :query "amber not cobalt"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber not cobalt"}
+ :C {:name "amber"}
+ :D {:name "not cobalt"}}
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:B]
+ :appdb-postgres [:B]
+ :semantic {:keyword [:B], :vector [:A :B :C :D]}}}
+ {:id "english-not-stopword"
+ :focus "same documents/query with English dropping not as a stopword"
+ :config "english"
+ :query "amber not cobalt"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber not cobalt"}
+ :C {:name "amber"}
+ :D {:name "not cobalt"}}
+ ;; With "not" dropped, PostgreSQL asks only for "amber" and "cobalt", so A matches too.
+ :expect {:in-place [:A :B :C :D]
+ :appdb-h2 [:B]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B :C :D]}}}
+ {:id "vector-only-match"
+ :focus "vector-only match enters semantic union without lexical overlap"
+ :config "simple"
+ :query "customers"
+ :docs {:A {:name "customers"}
+ :B {:name "clients"}
+ :C {:name "accounts"}
+ :D {:name "amber"}}
+ ;; B shares no word with the query but falls within the vector distance cutoff.
+ ;; C is related too, but the model places it outside the cutoff.
+ :expect {:in-place [:A]
+ :appdb-h2 [:A]
+ :appdb-postgres [:A]
+ :semantic {:keyword [:A], :vector [:A :B]}}}
+ {:id "english-stopword-only"
+ :focus "a query consisting only of an English stopword"
+ :config "english"
+ :query "the"
+ :docs {:A {:name "the"}
+ :B {:name "theater"}
+ :C {:name "other"}
+ :D {:name "widget"}}
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A :B :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A]}}}
+ {:id "simple-stopword-only"
+ :focus "same stopword-only query with simple configuration"
+ :config "simple"
+ :query "the"
+ :docs {:A {:name "the"}
+ :B {:name "theater"}
+ :C {:name "other"}
+ :D {:name "widget"}}
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A :B :C]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A]}}}
+ {:id "percent-punctuation"
+ :focus "percent is literal in substring search but token punctuation in PostgreSQL"
+ :config "simple"
+ :query "foo%bar"
+ :docs {:A {:name "fooxbar"}
+ :B {:name "foobar"}
+ :C {:name "foo%bar"}
+ :D {:name "foo bar"}
+ :E {:name "barfoo"}
+ :F {:name "foo-bar"}
+ :G {:name "foopizza"}}
+ ;; PostgreSQL treats % as token punctuation; H2 and in-place require the literal character.
+ ;; Tokenization suits prose, literal matching code-like text.
+ :expect {:in-place [:C]
+ :appdb-h2 [:C]
+ :appdb-postgres [:C :D :F]
+ :semantic {:keyword [:C :D :F], :vector [:A :B :C :D :F :G]}}}
+ {:id "underscore-punctuation"
+ :focus "underscore is literal in substring search but token punctuation in PostgreSQL"
+ :config "simple"
+ :query "a_b"
+ :docs {:A {:name "acb"}
+ :B {:name "a_b"}
+ :C {:name "ab"}
+ :D {:name "a b"}
+ :E {:name "a-b"}
+ :F {:name "xacb"}}
+ :expect {:in-place [:B]
+ :appdb-h2 [:B]
+ :appdb-postgres [:B :D :E]
+ :semantic {:keyword [:B :D :E], :vector [:B :C :D :E]}}}
+ {:id "percent-only"
+ :focus "percent alone matches only literal percent text in substring search"
+ :config "simple"
+ :query "%"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}
+ :C {:name "indigo"}
+ :D {:name "100% complete"}}
+ :expect {:in-place [:D]
+ :appdb-h2 [:D]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector []}}}
+ {:id "english-phrase-stopword"
+ :focus "English stopword inside a positional phrase"
+ :config "english"
+ :query "\"amber and cobalt\""
+ :docs {:A {:name "amber and cobalt"}
+ :B {:name "amber cobalt"}
+ :C {:name "amber bright cobalt"}
+ :D {:name "amber and bright cobalt"}
+ :E {:name "\"amber and cobalt\""}}
+ :expect {:in-place [:A :D :E]
+ :appdb-h2 [:E]
+ :appdb-postgres [:A :C :E]
+ :semantic {:keyword [:A :C :E], :vector [:A :B :C :D :E]}}
+ :comparisons
+ ;; PostgreSQL keeps the stopword's position, so any word can fill it and C matches.
+ ;; Without phrase support, H2 cannot exclude D.
+ [{:focus "English stopword inside a phrase"
+ :correct [:A :E]
+ :alternatives
+ {:appdb-h2 {:query "amber and cobalt", :hits [:A :D :E]}}}]}
+ {:id "simple-phrase-and"
+ :focus "same phrase with simple configuration retaining and"
+ :config "simple"
+ :query "\"amber and cobalt\""
+ :docs {:A {:name "amber and cobalt"}
+ :B {:name "amber cobalt"}
+ :C {:name "amber bright cobalt"}
+ :D {:name "amber and bright cobalt"}
+ :E {:name "\"amber and cobalt\""}}
+ :expect {:in-place [:A :D :E]
+ :appdb-h2 [:E]
+ :appdb-postgres [:A :E]
+ :semantic {:keyword [:A :E], :vector [:A :B :C :D :E]}}}
+ {:id "unfinished-quote"
+ :focus "unfinished opening quote keeps phrase but completes final word"
+ :config "simple"
+ :query "\"amber co"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber corgi"}
+ :C {:name "amber bright cobalt"}
+ :D {:name "\"amber co"}
+ :E {:name "amber co"}
+ :F {:name "\"amber co\""}}
+ :expect {:in-place [:A :B :C :D :E :F]
+ :appdb-h2 [:D :F]
+ :appdb-postgres [:A :B :D :E :F]
+ :semantic {:keyword [:A :B :D :E :F], :vector [:A :B :C :D :E :F]}}
+ :comparisons
+ [{:focus "unfinished quote with final-word completion"
+ :correct [:A :B :D :E :F]
+ :alternatives
+ {:in-place {:query "amber co", :hits [:A :B :C :D :E :F]}
+ :appdb-h2 {:query "amber co", :hits [:A :B :C :D :E :F]}}}]}
+ {:id "closed-quote"
+ :focus "closing quote disables final-word completion"
+ :config "simple"
+ :query "\"amber co\""
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber corgi"}
+ :C {:name "amber bright cobalt"}
+ :D {:name "\"amber co"}
+ :E {:name "amber co"}
+ :F {:name "\"amber co\""}}
+ :expect {:in-place [:D :F]
+ :appdb-h2 [:F]
+ :appdb-postgres [:D :E :F]
+ :semantic {:keyword [:D :E :F], :vector [:A :B :C :D :E :F]}}}
+ {:id "or-branch-prefix"
+ :focus "only final OR-branch term receives prefix completion"
+ :config "simple"
+ :query "amb or co"
+ :docs {:A {:name "amber"}
+ :B {:name "amb"}
+ :C {:name "cobalt"}
+ :D {:name "corgi"}
+ :E {:name "taco"}
+ :F {:name "amber cobalt"}
+ :G {:name "amb or cobalt"}
+ :H {:name "orbit"}}
+ :expect {:in-place [:A :B :C :D :E :F :G :H]
+ :appdb-h2 [:G]
+ :appdb-postgres [:B :C :D :F :G]
+ :semantic {:keyword [:B :C :D :F :G], :vector [:B :G]}}
+ :comparisons
+ ;; Both typed terms are word prefixes; PostgreSQL completes only the last.
+ [{:focus "prefix completion on every OR branch"
+ :correct [:A :B :C :D :F :G]
+ :alternatives
+ {:in-place {:query "amb co", :hits [:A :B :C :D :E :F :G]}
+ :appdb-h2 {:query "co", :hits [:C :D :E :F :G]}}}]}
+ {:id "negated-prefix"
+ :focus "final negated term is also prefix-completed"
+ :config "simple"
+ :query "amber -co"
+ :docs {:A {:name "amber"}
+ :B {:name "amber cobalt"}
+ :C {:name "amber corgi"}
+ :D {:name "amber taco"}
+ :E {:name "amber -co"}
+ :F {:name "cobalt"}}
+ :expect {:in-place [:A :B :C :D :E]
+ :appdb-h2 [:E]
+ :appdb-postgres [:A :D]
+ :semantic {:keyword [:A :D], :vector [:A :B :C :D :E]}}
+ :comparisons
+ [{:focus "negation of a prefix"
+ :correct [:A :D]
+ :alternatives
+ {:in-place {:query "amber", :hits [:A :B :C :D :E]}
+ :appdb-h2 {:query "amber", :hits [:A :B :C :D :E]}}}]}
+ {:id "negation-only"
+ :focus "negation-only query is a broad PostgreSQL complement"
+ :config "simple"
+ :query "-cobalt"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}
+ :C {:name "amber cobalt"}
+ :D {:name "-cobalt"}
+ :E {:name "indigo"}}
+ ;; PostgreSQL treats this as the complement of "cobalt", returning otherwise unrelated rows.
+ ;; That broad result is likely poor search UX, but is current.
+ :expect {:in-place [:D]
+ :appdb-h2 [:D]
+ :appdb-postgres [:A :E]
+ :semantic {:keyword [:A :E], :vector [:D]}}}
+ {:id "like-escape-percent"
+ :focus "LIKE escape character and percent are both literal query text"
+ :config "simple"
+ :query "!%"
+ :docs {:A {:name "literal !% marker"}
+ :B {:name "literal % marker"}
+ :C {:name "literal ! marker"}
+ :D {:name "literal marker"}}
+ :expect {:in-place [:A]
+ :appdb-h2 [:A]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A :C]}}}
+ {:id "or-only-operator"
+ :focus "operator-only or is literal for substring engines but empty for tsquery"
+ :config "simple"
+ :query "or"
+ :docs {:A {:name "or"}
+ :B {:name "orbit"}
+ :C {:name "north"}
+ :D {:name "amber"}}
+ ;; PostgreSQL sees only an operator, so it has no searchable lexeme.
+ ;; Literal substring engines still find "or", including its occurrences inside words.
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:A :B :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A]}}
+ :comparisons
+ ;; The intended match is the word or a word starting with it; "north" only contains it.
+ [{:focus "quoting or recovers the word but not prefix matches"
+ :correct [:A :B]
+ :alternatives
+ {:appdb-postgres {:query "\"or\"", :hits [:A]}}}]}
+ ;; Controls: with the simple configuration, every lexical engine can express these intents, some only by
+ ;; adapting the query.
+ ;; No document contains the word inside a longer word; see or-only-operator for that trap.
+ {:id "or-word-control"
+ :focus "control: or as a literal word"
+ :config "simple"
+ :query "or"
+ :docs {:A {:name "or"}
+ :B {:name "amber"}
+ :C {:name "this or that"}}
+ :expect {:in-place [:A :C]
+ :appdb-h2 [:A :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A :C]}}
+ :comparisons
+ [{:focus "quoting or makes it a searchable word"
+ :correct [:A :C]
+ :alternatives
+ {:appdb-postgres {:query "\"or\"", :hits [:A :C]}}}]}
+ {:id "and-word-control"
+ :focus "control: and as a literal word"
+ :config "simple"
+ :query "and"
+ :docs {:A {:name "and"}
+ :B {:name "amber"}
+ :C {:name "salt and pepper"}}
+ :expect {:in-place [:A :C]
+ :appdb-h2 [:A :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A]}}
+ :comparisons
+ [{:focus "quoting and makes it a searchable word"
+ :correct [:A :C]
+ :alternatives
+ {:appdb-postgres {:query "\"and\"", :hits [:A :C]}}}]}
+ ;; The same controls with English, the default on an English-locale instance with a PostgreSQL app db.
+ ;; Both words are English stopwords, so PostgreSQL cannot require them even when quoted.
+ {:id "english-or-word"
+ :focus "same or control with English dropping or as a stopword"
+ :config "english"
+ :query "or"
+ :docs {:A {:name "or"}
+ :B {:name "amber"}
+ :C {:name "this or that"}}
+ :expect {:in-place [:A :C]
+ :appdb-h2 [:A :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A :C]}}
+ :comparisons
+ [{:focus "quoting or cannot recover an English stopword"
+ :correct [:A :C]
+ :alternatives
+ {:appdb-postgres {:query "\"or\"", :hits []}}}]}
+ {:id "english-and-word"
+ :focus "same and control with English dropping and as a stopword"
+ :config "english"
+ :query "and"
+ :docs {:A {:name "and"}
+ :B {:name "amber"}
+ :C {:name "salt and pepper"}}
+ :expect {:in-place [:A :C]
+ :appdb-h2 [:A :C]
+ :appdb-postgres []
+ :semantic {:keyword [], :vector [:A]}}
+ :comparisons
+ [{:focus "quoting and cannot recover an English stopword"
+ :correct [:A :C]
+ :alternatives
+ {:appdb-postgres {:query "\"and\"", :hits []}}}]}
+ {:id "field-term-agreement"
+ :focus "ordinary term matches either indexed text field"
+ :config "simple"
+ :query "amber"
+ :docs {:A {:name "amber"}
+ :B {:name "indigo", :description "amber"}
+ :C {:name "cobalt"}}
+ ;; All four engines agree on an exact ordinary term in either field.
+ :expect {:in-place [:A :B]
+ :appdb-h2 [:A :B]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B]}}}
+ {:id "multiword-agreement"
+ :focus "multiword terms present together, including across fields"
+ :config "simple"
+ :query "amber cobalt"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber", :description "cobalt"}
+ :C {:name "indigo"}}
+ ;; With no one-term-only document, OR and AND produce the same result.
+ :expect {:in-place [:A :B]
+ :appdb-h2 [:A :B]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B]}}}
+ {:id "prefix-agreement"
+ :focus "final-word prefix without partial or infix distractors"
+ :config "simple"
+ :query "amber co"
+ :docs {:A {:name "amber cobalt"}
+ :B {:name "amber corgi"}
+ :C {:name "indigo"}}
+ ;; Last-word completion and substring matching coincide on these documents.
+ :expect {:in-place [:A :B]
+ :appdb-h2 [:A :B]
+ :appdb-postgres [:A :B]
+ :semantic {:keyword [:A :B], :vector [:A :B]}}}
+ {:id "operator-empty-agreement"
+ :focus "operator-only query without a literal occurrence"
+ :config "simple"
+ :query "or"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}
+ :C {:name "indigo"}}
+ ;; PostgreSQL discards the operator; the substring engines find no literal.
+ :expect {:in-place []
+ :appdb-h2 []
+ :appdb-postgres []
+ :semantic {:keyword [], :vector []}}}
+ {:id "unmatched-term"
+ :focus "ordinary term absent from every document"
+ :config "simple"
+ :query "zircon"
+ :docs {:A {:name "amber"}
+ :B {:name "cobalt"}}
+ ;; Unlike operator-empty-agreement, every engine searches for a term but finds no match.
+ :expect {:in-place []
+ :appdb-h2 []
+ :appdb-postgres []
+ :semantic {:keyword [], :vector []}}}
+ {:id "lexical-and-vector-union"
+ :focus "lexical conjunction versus semantic vector union"
+ :config "simple"
+ :query "cats dogs"
+ :docs {:A {:name "cats"}
+ :B {:name "dogs"}
+ :C {:name "cats dogs"}
+ :D {:name "quarterly revenue"}}
+ ;; App-db needs both words in one row.
+ ;; The vector arm also retrieves each one-word row.
+ :expect {:in-place [:A :B :C]
+ :appdb-h2 [:C]
+ :appdb-postgres [:C]
+ :semantic {:keyword [:C], :vector [:A :B :C]}}}]