From 3cba4fc6049c447ffbb047ba57898afb3217793e Mon Sep 17 00:00:00 2001 From: Valery Mironov <32071355+MBkkt@users.noreply.github.com> Date: Fri, 15 Dec 2023 19:12:07 +0100 Subject: [PATCH 01/11] Add wildcard analyzer --- .../content/3.12/index-and-search/analyzers.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/site/content/3.12/index-and-search/analyzers.md b/site/content/3.12/index-and-search/analyzers.md index d03d498b52..baeba651d9 100644 --- a/site/content/3.12/index-and-search/analyzers.md +++ b/site/content/3.12/index-and-search/analyzers.md @@ -141,6 +141,7 @@ The following Analyzer types are available: indexing geo-spatial data (Enterprise Edition only) - [`geopoint`](#geopoint): breaks up JSON data describing a coordinate pair into a set of indexable tokens +- [`wildcard`](#wildcard): to able run heavy wildcard queries on large string field The following table compares the Analyzers for **text processing**: @@ -1578,6 +1579,23 @@ db._query(`LET point = GEO_POINT(6.93, 50.94) ~db._drop("geo"); ``` +### Wildcard + +Paramters: + ngramSize (required) -- unsigned integer, should be >= 2 + analyzer (optional) -- same parameter as for minhash analyzer + +It's needed when user have large string field and want to run not-prefix wildcard queries on it. + +This analyzer have features validation: +It's not possible to create it with offset feature (same as for elastic). +So it's possible to valid combinations of features: [] and ["frequency", "position"]. +Second option is required more memory, but doesn't need to read stored column values for prefix/suffix/exact queries ( %something%, %something, something% , something) + +Also if you have ngramSize greater than simple part in wildcard query it can be slowdown, example +ngramSize == 4, and pattern %jo%jo%ref%, will search ref% and then made linear post-validation via icu regex engine +https://www.elastic.co/blog/find-strings-within-strings-faster-with-the-new-elasticsearch-wildcard-field (simplified description how it works) + ## Built-in Analyzers There is a set of built-in Analyzers which are available by default for From 57bac9ff1c37742d6070930429ce028ec224f0b9 Mon Sep 17 00:00:00 2001 From: Valery Mironov <32071355+MBkkt@users.noreply.github.com> Date: Fri, 15 Dec 2023 19:14:07 +0100 Subject: [PATCH 02/11] Update site/content/3.12/index-and-search/analyzers.md --- site/content/3.12/index-and-search/analyzers.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/site/content/3.12/index-and-search/analyzers.md b/site/content/3.12/index-and-search/analyzers.md index baeba651d9..f6f195a2a9 100644 --- a/site/content/3.12/index-and-search/analyzers.md +++ b/site/content/3.12/index-and-search/analyzers.md @@ -1581,7 +1581,7 @@ db._query(`LET point = GEO_POINT(6.93, 50.94) ### Wildcard -Paramters: +Parameters: ngramSize (required) -- unsigned integer, should be >= 2 analyzer (optional) -- same parameter as for minhash analyzer From 7b7383410e3abda52b1ba04eb13c073d95b9154d Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Thu, 11 Jan 2024 09:33:54 +0100 Subject: [PATCH 03/11] Rework --- .../3.12/index-and-search/analyzers.md | 99 +++++++++++++++---- .../version-3.12/whats-new-in-3-12.md | 11 +++ 2 files changed, 91 insertions(+), 19 deletions(-) diff --git a/site/content/3.12/index-and-search/analyzers.md b/site/content/3.12/index-and-search/analyzers.md index f6f195a2a9..b05eba082a 100644 --- a/site/content/3.12/index-and-search/analyzers.md +++ b/site/content/3.12/index-and-search/analyzers.md @@ -120,11 +120,13 @@ The following Analyzer types are available: - [`delimiter`](#delimiter): splits into tokens at user-defined character - [`stem`](#stem): applies stemming to the value as a whole - [`norm`](#norm): applies normalization to the value as a whole -- [`ngram`](#ngram): creates _n_-grams from value with user-defined lengths +- [`ngram`](#ngram): creates _n_-grams from the value with user-defined lengths - [`text`](#text): tokenizes text strings into words, optionally with stemming, normalization, stop-word filtering and edge _n_-gram generation - [`segmentation`](#segmentation): tokenizes text in a language-agnostic manner, optionally with normalization +- [`wildcard`](#wildcard): can apply another Analyzer and creates _n_-grams to + enable fast partial matching for large strings - [`aql`](#aql): runs an AQL query to prepare tokens for index - [`pipeline`](#pipeline): chains multiple Analyzers - [`stopwords`](#stopwords): removes the specified tokens from the input @@ -141,7 +143,6 @@ The following Analyzer types are available: indexing geo-spatial data (Enterprise Edition only) - [`geopoint`](#geopoint): breaks up JSON data describing a coordinate pair into a set of indexable tokens -- [`wildcard`](#wildcard): to able run heavy wildcard queries on large string field The following table compares the Analyzers for **text processing**: @@ -1049,6 +1050,83 @@ db._query(`LET str = 'Test\twith An_EMAIL-address+123@example.org\n蝴蝶。\u20 ~analyzers.remove(graphic.name); ``` +### `wildcard` + +Introduced in: v3.12.0 + +An Analyzer that creates _n_-grams to enable fast partial matching for wildcard +queries if you have large string values, especially if you want to search for +suffixes or substrings in the middle of strings (infixes) as opposed to prefixes. + +It can apply an Analyzer of your choice before creating the _n_-grams, for example, +to normalize text for case-insensitive and accent-insensitive search. + +See [Wildcard Search with ArangoSearch](arangosearch/wildcard-search.md) for an +example of how to use this Analyzer with Views, and +[Inverted indexes](indexing/working-with-indexes/inverted-indexes.md#wildcard-search) +for an example using a standalone inverted index. + +The *properties* allowed for this Analyzer are an object with the following +attributes: + +- `ngramSize` (number, _required_): unsigned integer for the _n_-gram length, + needs to be at least `2`. It can be greater than the substrings between + wildcards that you want to search for, e.g. `4` with an expected search pattern + of `%up%if%ref%` (substrings of length 2 and 3 between `%`), but this leads to + a slower search (for `ref%` with post-validation using the ICU regular expression + engine) +- `analyzer` (object, _optional_): an Analyzer definition-like objects with + `type` and `properties` attributes + +You cannot set the `offset` [Analyzer features](#analyzer-features) for this +Analyzer. You can create the Analyzer without features, or use +`["frequency", "position"]` which uses more memory but doesn't need to read +stored column values for prefix, suffix, infix, and exact queries (`something%`, +`%something`, `%something%`, `something`, but not `some%thing` or `%some%thing%`) + +The set of _n_-grams that are created for each input token includes one start +_n_-gram and `ngramSize - 1` end _n_-grams using `"\uFFFD"` as start marker +respectively end marker. For example, with an `ngramSize` of `3` and the input +`"graph"`, the generated _n_-grams are: +- `"�gr"` +- `"gra"` +- `"rap"` +- `"aph"` +- `"ph�"` +- `"h�"` + +**Examples** + +```js +--- +name: analyzerWildcard1 +description: | + Create a `wildcard` Analyzer with an _n_-gram size of 4 and without enabling + Analyzer features: +--- +var analyzers = require("@arangodb/analyzers"); +var analyzerWildcard = analyzers.save("wildcard_4", "wildcard", { ngramSize: 4 }, []); + +db._query(`RETURN TOKENS("The quick brown Foxx", "wildcard_4")`).toArray(); +~analyzers.remove(analyzerWildcard.name); +``` + +```js +--- +name: analyzerWildcard2 +description: | + Use a `norm` Analyzer to normalize the input to lowercase and convert accented + characters to their base characters, then create trigrams from the string: +--- +var analyzers = require("@arangodb/analyzers"); +var analyzerWildcard = analyzers.save("wildcard_3", "wildcard", { ngramSize: 3, "analyzer": { + type: "norm", properties: { locale: "en", accent: false, case: "lower" } +} }, ["frequency","position"]); + +db._query(`RETURN TOKENS("The quick brown Foxx", "wildcard_3")`).toArray(); +~analyzers.remove(analyzerWildcard.name); +``` + ### `minhash` {{< tag "ArangoDB Enterprise Edition" "ArangoGraph" >}} @@ -1579,23 +1657,6 @@ db._query(`LET point = GEO_POINT(6.93, 50.94) ~db._drop("geo"); ``` -### Wildcard - -Parameters: - ngramSize (required) -- unsigned integer, should be >= 2 - analyzer (optional) -- same parameter as for minhash analyzer - -It's needed when user have large string field and want to run not-prefix wildcard queries on it. - -This analyzer have features validation: -It's not possible to create it with offset feature (same as for elastic). -So it's possible to valid combinations of features: [] and ["frequency", "position"]. -Second option is required more memory, but doesn't need to read stored column values for prefix/suffix/exact queries ( %something%, %something, something% , something) - -Also if you have ngramSize greater than simple part in wildcard query it can be slowdown, example -ngramSize == 4, and pattern %jo%jo%ref%, will search ref% and then made linear post-validation via icu regex engine -https://www.elastic.co/blog/find-strings-within-strings-faster-with-the-new-elasticsearch-wildcard-field (simplified description how it works) - ## Built-in Analyzers There is a set of built-in Analyzers which are available by default for diff --git a/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md b/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md index 9258bbae15..e58899eb50 100644 --- a/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md +++ b/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md @@ -53,6 +53,17 @@ for details. ## Analyzers +### `wildcard` Analyzer + +You can use the new `wildcard` Analyzer in combination with an inverted index or +View to accelerate wildcard searches, especially if you want to find non-prefix +partial matches in long strings. + +The Analyzer can apply another Analyzer of your choice before creating _n_-grams +that are then used in `LIKE` searches with `_` and `%` wildcards. + +See [Transforming data with Analyzers](../../index-and-search/analyzers.md#wildcard) +for details. ## Improved memory accounting and usage From 2d1b2f6554f5064eabcfefd5d54ad7fa7f91fa4e Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Mon, 5 Feb 2024 14:12:46 +0100 Subject: [PATCH 04/11] Add examples and more release notes --- .../features/highlights-by-version.md | 4 +- .../3.12/index-and-search/analyzers.md | 13 +- .../arangosearch/wildcard-search.md | 195 +++++++++++++++++- .../working-with-indexes/inverted-indexes.md | 22 ++ .../version-3.12/api-changes-in-3-12.md | 15 ++ 5 files changed, 231 insertions(+), 18 deletions(-) diff --git a/site/content/3.12/about-arangodb/features/highlights-by-version.md b/site/content/3.12/about-arangodb/features/highlights-by-version.md index be199f5f13..1dca3485a0 100644 --- a/site/content/3.12/about-arangodb/features/highlights-by-version.md +++ b/site/content/3.12/about-arangodb/features/highlights-by-version.md @@ -13,7 +13,9 @@ aliases: **All Editions** -- +- [**`wildcard` Analyzer**](../../index-and-search/analyzers.md#wildcard): + Accelerate wildcard searches against Views and inverted indexes with _n_-grams + to quickly find candidate matches. **Enterprise Edition** diff --git a/site/content/3.12/index-and-search/analyzers.md b/site/content/3.12/index-and-search/analyzers.md index 33003b911e..c9fd2d2f5f 100644 --- a/site/content/3.12/index-and-search/analyzers.md +++ b/site/content/3.12/index-and-search/analyzers.md @@ -1116,8 +1116,8 @@ suffixes or substrings in the middle of strings (infixes) as opposed to prefixes It can apply an Analyzer of your choice before creating the _n_-grams, for example, to normalize text for case-insensitive and accent-insensitive search. -See [Wildcard Search with ArangoSearch](arangosearch/wildcard-search.md) for an -example of how to use this Analyzer with Views, and +See [Wildcard Search with ArangoSearch](arangosearch/wildcard-search.md#wildcard-analyzer-examples) +for an example of how to use this Analyzer with Views, and [Inverted indexes](indexing/working-with-indexes/inverted-indexes.md#wildcard-search) for an example using a standalone inverted index. @@ -1129,7 +1129,7 @@ attributes: wildcards that you want to search for, e.g. `4` with an expected search pattern of `%up%if%ref%` (substrings of length 2 and 3 between `%`), but this leads to a slower search (for `ref%` with post-validation using the ICU regular expression - engine) + engine). A value of `3` is a good default, `2` is better for short strings - `analyzer` (object, _optional_): an Analyzer definition-like objects with `type` and `properties` attributes @@ -1137,7 +1137,7 @@ You cannot set the `offset` [Analyzer features](#analyzer-features) for this Analyzer. You can create the Analyzer without features, or use `["frequency", "position"]` which uses more memory but doesn't need to read stored column values for prefix, suffix, infix, and exact queries (`something%`, -`%something`, `%something%`, `something`, but not `some%thing` or `%some%thing%`) +`%something`, `%something%`, `something`, but not `some%thing` or `%some%thin_`) The set of _n_-grams that are created for each input token includes one start _n_-gram and `ngramSize - 1` end _n_-grams using `"\uFFFD"` as start marker @@ -1170,8 +1170,9 @@ db._query(`RETURN TOKENS("The quick brown Foxx", "wildcard_4")`).toArray(); --- name: analyzerWildcard2 description: | - Use a `norm` Analyzer to normalize the input to lowercase and convert accented - characters to their base characters, then create trigrams from the string: + Use a `norm` Analyzer in a `wildcard` Analyzer to normalize the input to + lowercase and convert accented characters to their base characters before + creating trigrams from the string: --- var analyzers = require("@arangodb/analyzers"); var analyzerWildcard = analyzers.save("wildcard_3", "wildcard", { ngramSize: 3, "analyzer": { diff --git a/site/content/3.12/index-and-search/arangosearch/wildcard-search.md b/site/content/3.12/index-and-search/arangosearch/wildcard-search.md index c00a053421..95e517deec 100644 --- a/site/content/3.12/index-and-search/arangosearch/wildcard-search.md +++ b/site/content/3.12/index-and-search/arangosearch/wildcard-search.md @@ -6,22 +6,64 @@ description: >- Search for strings with placeholders that stand for one or many arbitrary characters archetype: default --- -You can use the `LIKE()` function for this search technique to find strings -that start with, contain or end with a certain substring, but it can do more -than that. You can place the special characters `_` and `%` as wildcards for -single or zero-or-more characters in the search string to match multiple -partial strings. +You can use the `LIKE()` function and `LIKE` operator for this search technique +to find strings that start with, contain, or end with a certain substring. You +can also search for complex patterns with multiple placeholders. Place the +special characters `_` and `%` as wildcards for any single or zero-or-more +characters in the search string to match multiple partial strings. + +``` +prefix% +%infix% +%suffix +%complex%pat_ern +``` + +Wildcard searching can be an alternative to tokenizing text into words and then +searching for words in a particular order ([Phrase and Proximity Search](phrase-and-proximity-search.md)). +It is especially useful if you want to search for substrings that include +characters that are considered word boundaries like punctuation and whitespace +and would normally get removed when tokenizing text. + +## Index acceleration The [ArangoSearch `LIKE()` function](../../aql/functions/arangosearch.md#like) is backed by View indexes. In contrast, the -[String `LIKE()` function](../../aql/functions/string.md#like) cannot utilize any -sort of index. Another difference is that the ArangoSearch variant does not -accept a third argument to make matching case-insensitive. You can control this -via Analyzers instead, also see +[string `LIKE()` function](../../aql/functions/string.md#like) cannot utilize any +sort of index. This applies to the [`LIKE` operator](../../aql/operators.md#comparison-operators), +too, which you can use instead of the function. +Another difference is that the ArangoSearch variant of the `LIKE()` function does +not accept a third argument to make matching case-insensitive. You can control +this via Analyzers instead, also see [Case-insensitive Search with ArangoSearch](case-sensitivity-and-diacritics.md). Which of the two equally named functions is used is determined by the context. -It is the ArangoSearch variant in `SEARCH` operations and the String variant -everywhere else. +The ArangoSearch variant is used in `SEARCH` operations. It is also used when +you have an inverted index and use the `LIKE()` function with two arguments or +the `LIKE` operator in `FILTER` operations. The string variant is used everywhere +else, including using the `LIKE()` function with three arguments in `FILTER` +operations together with an inverted index. + +You can further accelerate wildcard queries by creating a specialized `wildcard` +Analyzer and using it in a View or inverted index on the desired document +attributes. The `wildcard` Analyzer creates _n_-grams that can internally be +used to quickly find candidates, followed by post-filtering to remove +false-positive matches. The _n_-gram size should be configured depending on the +data and expected wildcard search strings. The substrings between wildcards of a +search string that are at least as long as the _n_-gram size are used to find +candidates. For example, the longest substring of `%up%if%ref%` is `ref`. +With an _n_-gram size of `3`, the `ref` substring can be looked up quickly to +find candidates, achieving a faster search as with a differently indexed attribute, +e.g. using the `identity` Analyzer. With an _n_-gram size of `2`, it is also +fast to find candidates, as `up`, `if`, `re`, and `ef` can be used to look up +potential matches. However, with an _n_-gram size of `4` or greater, ArangoSearch +has to treat all entries as candidates for this search string because the +substrings between wildcards are shorter than the _n_-gram size. It needs to +post-filter more, which is slower as with a differently indexed attribute. +Therefore, the _n_-gram size should generally be set to a small number so that +virtually all wildcard searches can get a speedup from an attribute being indexed +with the `wildcard` Analyzer. On the other hand, it should not be set +unnecessarily small, as the lookup performance degrades with many duplicate +_n_-grams in the index, which is more likely with shorter _n_-grams. ## Wildcard Syntax @@ -182,3 +224,134 @@ Bind parameters: ``` The query constructs the wildcard string `%y\\_%` and will match `Cry_Wolf`. + +## Wildcard Analyzer Examples + +You can index attributes with a `wildcard` Analyzer to improve the wildcard +search performance. + +### Dataset + +[IMDB movie dataset](example-datasets.md#imdb-movie-dataset) + +### Custom Analyzer + +```js +--- +name: analyzer_wildcard_sample +description: | + Create a `wildcard` Analyzer with a small _n_-gram size, for example, in arangosh. + You can let the Analyzer pre-process the inputs, like with a `norm` Analyzer to + enable case-insensitive and accent-insensitive wildcard search. Create a matching + standalone Analyzer so that you can pre-process wildcard search strings in the + same fashion: +--- +var analyzers = require("@arangodb/analyzers"); +var wildcardNormAnalyzer = analyzers.save("wildcard_norm", "wildcard", { ngramSize: 3, analyzer: { type: "norm", properties: { locale: "en", accent: false, case: "lower" } } }, ["frequency", "norm"]); +var matchingNormAnalyzer = analyzers.save("only_norm", "norm", { locale: "en", accent: false, case: "lower" }); +~analyzers.remove("wildcard_norm"); +~analyzers.remove("only_norm"); +``` + +The `frequency` and `norm` [Analyzer features](../analyzers.md#analyzer-features) +are set for improved performance of simple wildcard searches at the expense of +higher memory usage. + +### View definition + +{{< tabs "view-definition">}} + +{{< tab "`search-alias` View" >}} +```js +db.imdb_vertices.ensureIndex({ name: "inv-wildcard", type: "inverted", fields: [ { name: "description", analyzer: "wildcard_norm" } ] }); +db._createView("imdb", "search-alias", { indexes: [ { collection: "imdb_vertices", index: "inv-wildcard" } ] }); +``` +{{< /tab >}} + +{{< tab "`arangosearch` View" >}} +```json +{ + "links": { + "imdb_vertices": { + "fields": { + "description": { + "analyzers": [ + "wildcard_norm" + ] + } + } + } + } +} +``` +{{< /tab >}} + +{{< /tabs >}} + +### AQL queries + +Match movie descriptions that end with `AY!` case-insensitively by taking the +search string and applying the `norm` Analyzer that matches the one of the +`wildcard` Analyzer (both normalizing to lowercase), and then using the `LIKE` +operator to perform a wildcard search: + +{{< tabs "view-definition">}} + +{{< tab "`search-alias` View" >}} +```aql +LET search = "%AY!" +LET searchNormalized = TOKENS(search, "only_norm")[0] +FOR doc IN imdb + SEARCH doc.description LIKE searchNormalized + RETURN doc.description +``` +{{< /tab >}} + +{{< tab "`arangosearch` View" >}} +```aql +LET search = "%AY!" +LET searchNormalized = TOKENS(search, "only_norm")[0] +FOR doc IN imdb + SEARCH ANALYZER(doc.description LIKE searchNormalized, "wildcard_norm") + RETURN doc.description +``` +{{< /tab >}} + +{{< /tabs >}} + +| Result | +|:-------| +| Pitch, the mean-spirited devil, is trying to ruin Christmas. Santa Claus teams up … to save the d**ay!** | +| Join Little Joe … all the way to Dodge Ball City -- with Little Joe's faith being tested every step of the w**ay!** | +| Surrounded by huge walls … they have to decide whether it's better to do things their way or God's w**ay!** | +| Tautly directed by Jack Sholder … It's Back to the Future meets Groundhog D**ay!** | + +Match movie descriptions that contain the following pattern (case-insensitive): +a letter `C`, an arbitrary character, the letter `T`, an arbitrary character, +a space, two hyphens, and another space. + +{{< tabs "view-definition">}} + +{{< tab "`search-alias` View" >}} +LET search = "%C_T_ -- %" +LET searchNormalized = TOKENS(search, "only_norm")[0] +FOR doc IN imdb + SEARCH doc.description LIKE searchNormalized + RETURN {d: doc.description } +{{< /tab >}} + +{{< tab "`arangosearch` View" >}} +LET search = "%C_T_ -- %" +LET searchNormalized = TOKENS(search, "only_norm")[0] +FOR doc IN imdb + SEARCH ANALYZER(doc.description LIKE searchNormalized, "wildcard_norm") + RETURN {d: doc.description } +{{< /tab >}} + +{{< /tabs >}} + +| Result | +|:-------| +| New York detective John McClane is back … -- and his beloved **city --** in a deadly game that demands their concentration. | +| When Madame Adelaide Bonfamille leaves her … domesticated house **cats --** the butler plots to steal the money and kidnaps the heirs, … | +| Join Little Joe … all the way to Dodge Ball **City --** with Little Joe's faith being tested every step of the way! | diff --git a/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md b/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md index 336ee42e87..4e26201422 100644 --- a/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md +++ b/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md @@ -462,6 +462,28 @@ db._query(`FOR doc IN imdb_vertices OPTIONS { indexHint: "inv-ci", forceIndexHin RETURN doc.title`); ``` +Accelerate wildcard searches by indexing with the `wildcard` Analyzer, for example, +match movie descriptions that end with `AY!` case-insensitively by taking the +search string and applying a `norm` Analyzer that matches the one of a +`wildcard` Analyzer (both normalizing to lowercase), and then using the `LIKE` +operator to perform a wildcard search: + +```js +var analyzers = require("@arangodb/analyzers"); +var wildcardNormAnalyzer = analyzers.save("wildcard_norm", "wildcard", { ngramSize: 3, analyzer: { type: "norm", properties: { locale: "en", accent: false, case: "lower" } } }, ["frequency", "norm"]); +var matchingNormAnalyzer = analyzers.save("only_norm", "norm", { locale: "en", accent: false, case: "lower" }); + +db.imdb_vertices.ensureIndex({ name: "inv-wildcard", type: "inverted", fields: [ { name: "description", analyzer: "wildcard_norm" } ] }); + +db._query(` + LET search = "%AY!" + LET searchNormalized = TOKENS(search, "only_norm")[0] + FOR doc IN imdb_vertices OPTIONS { indexHint: "inv-wildcard", forceIndexHint: true } + FILTER doc.description LIKE searchNormalized + RETURN doc.description +`); +``` + ### Full-text token search Search for movies with both `dinosaur` and `park` in their description: diff --git a/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md b/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md index c2d492519a..11917ad223 100644 --- a/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md +++ b/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md @@ -211,6 +211,21 @@ and [Monitoring per collection/database/user](../version-3.12/whats-new-in-3-12. ### Endpoints augmented +#### Analyzer API + +A new `wildcard` Analyzer with the following properties has been added, +affecting the `/_api/analyzer` endpoints: + +- `ngramSize` (number, _required_): unsigned integer, needs to be at least `2` +- `analyzer` (object, _optional_): an Analyzer definition-like objects with + `type` and `properties` attributes, where `type` is a string and `properties` + an object whose attributes depend on the `type` + +The `offset` Analyzer feature is not valid for this Analyzer. + +See [Transforming data with Analyzers](../../index-and-search/analyzers.md#wildcard) +for details. + #### View API Views of type `arangosearch` accept a new `optimizeTopK` View property for the From 7550dd6563fc918a7467ae8226a7902f8f204c77 Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 18:02:17 +0100 Subject: [PATCH 05/11] Don't try to drop collections that dropGraph deletes anyway --- .../develop/http-api/graphs/named-graphs.md | 28 +------------------ 1 file changed, 1 insertion(+), 27 deletions(-) diff --git a/site/content/3.12/develop/http-api/graphs/named-graphs.md b/site/content/3.12/develop/http-api/graphs/named-graphs.md index 8edd09bb45..fd8217c115 100644 --- a/site/content/3.12/develop/http-api/graphs/named-graphs.md +++ b/site/content/3.12/develop/http-api/graphs/named-graphs.md @@ -181,7 +181,6 @@ description: '' name: HttpGharialList --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); examples.loadGraph("routeplanner"); var url = "/_api/gharial"; @@ -1244,7 +1243,6 @@ description: '' name: HttpGharialDrop --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social?dropCollections=true"; var response = logCurlRequest('DELETE', url); @@ -1346,7 +1344,6 @@ description: '' name: HttpGharialListVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/vertex"; var response = logCurlRequest('GET', url); @@ -1769,7 +1766,6 @@ description: '' name: HttpGharialAddVertexCol --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/vertex"; body = { @@ -2184,7 +2180,6 @@ description: |- name: HttpGharialRemoveVertexCollection --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); var g = examples.loadGraph("social"); g._addVertexCollection("otherVertices"); var url = "/_api/gharial/social/vertex/otherVertices"; @@ -2204,17 +2199,13 @@ description: |- name: HttpGharialRemoveVertexCollectionFailed --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); var g = examples.loadGraph("social"); var url = "/_api/gharial/social/vertex/male"; -var response = logCurlRequest('DELETE', url); +var response = logCurlRequest('DELETE', url); // xpError(ERROR_GRAPH_NOT_IN_ORPHAN_COLLECTION) assert(response.code === 400); logJsonResponse(response); -db._drop("male"); -db._drop("female"); -db._drop("relation"); examples.dropGraph("social"); ``` @@ -2308,7 +2299,6 @@ description: '' name: HttpGharialListEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/edge"; var response = logCurlRequest('GET', url); @@ -2752,7 +2742,6 @@ description: '' name: HttpGharialAddEdgeCol --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/edge"; body = { @@ -3208,7 +3197,6 @@ description: '' name: HttpGharialReplaceEdgeCol --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/edge/relation"; body = { @@ -3596,7 +3584,6 @@ description: '' name: HttpGharialEdgeDefinitionRemove --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/edge/relation"; var response = logCurlRequest('DELETE', url); @@ -3875,7 +3862,6 @@ description: '' name: HttpGharialAddVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/vertex/male"; body = { @@ -4136,7 +4122,6 @@ description: '' name: HttpGharialGetVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/vertex/female/alice"; var response = logCurlRequest('GET', url); @@ -4525,7 +4510,6 @@ description: '' name: HttpGharialModifyVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); body = { age: 26 @@ -4917,7 +4901,6 @@ description: '' name: HttpGharialReplaceVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); body = { name: "Alice Cooper", @@ -5197,7 +5180,6 @@ description: '' name: HttpGharialDeleteVertex --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var url = "/_api/gharial/social/vertex/female/alice"; var response = logCurlRequest('DELETE', url); @@ -5560,10 +5542,6 @@ description: '' name: HttpGharialAddEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); -require("internal").db._drop("relation"); -require("internal").db._drop("female"); -require("internal").db._drop("male"); examples.loadGraph("social"); var url = "/_api/gharial/social/edge/relation"; body = { @@ -5836,7 +5814,6 @@ description: '' name: HttpGharialGetEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var any = require("@arangodb").db.relation.any(); var url = "/_api/gharial/social/edge/relation/" + any._key; @@ -6287,7 +6264,6 @@ description: '' name: HttpGharialPatchEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var any = require("@arangodb").db.relation.any(); var url = "/_api/gharial/social/edge/relation/" + any._key; @@ -6747,7 +6723,6 @@ description: '' name: HttpGharialPutEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var any = require("@arangodb").db.relation.any(); var url = "/_api/gharial/social/edge/relation/" + any._key; @@ -7049,7 +7024,6 @@ description: '' name: HttpGharialDeleteEdge --- var examples = require("@arangodb/graph-examples/example-graph.js"); -examples.dropGraph("social"); examples.loadGraph("social"); var any = require("@arangodb").db.relation.any(); var url = "/_api/gharial/social/edge/relation/" + any._key; From dc3dc3e43589a6b569d7fef37e95c8c2e195d6e0 Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 18:30:27 +0100 Subject: [PATCH 06/11] Fix old headline level 2 markup --- .../develop/foxx-microservices/reference/routers/request.md | 3 +-- .../content/3.10/release-notes/version-3.9/whats-new-in-3-9.md | 3 +-- .../develop/foxx-microservices/reference/routers/request.md | 3 +-- .../content/3.11/release-notes/version-3.9/whats-new-in-3-9.md | 3 +-- .../develop/foxx-microservices/reference/routers/request.md | 3 +-- .../content/3.12/release-notes/version-3.9/whats-new-in-3-9.md | 3 +-- 6 files changed, 6 insertions(+), 12 deletions(-) diff --git a/site/content/3.10/develop/foxx-microservices/reference/routers/request.md b/site/content/3.10/develop/foxx-microservices/reference/routers/request.md index 96a8ac24bb..721aead75e 100644 --- a/site/content/3.10/develop/foxx-microservices/reference/routers/request.md +++ b/site/content/3.10/develop/foxx-microservices/reference/routers/request.md @@ -274,8 +274,7 @@ Gets the value of a header by name. You can validate request headers using the Returns the header value. -is --- +## is `req.is(types): string` diff --git a/site/content/3.10/release-notes/version-3.9/whats-new-in-3-9.md b/site/content/3.10/release-notes/version-3.9/whats-new-in-3-9.md index 66d584cf72..82ccbffb28 100644 --- a/site/content/3.10/release-notes/version-3.9/whats-new-in-3-9.md +++ b/site/content/3.10/release-notes/version-3.9/whats-new-in-3-9.md @@ -117,8 +117,7 @@ Enterprise Edition. See [Optimizing View query performance](../../index-and-search/arangosearch/performance.md) for examples. -UI --- +## UI ### Rebalance Shards for all databases in Web UI diff --git a/site/content/3.11/develop/foxx-microservices/reference/routers/request.md b/site/content/3.11/develop/foxx-microservices/reference/routers/request.md index 96a8ac24bb..721aead75e 100644 --- a/site/content/3.11/develop/foxx-microservices/reference/routers/request.md +++ b/site/content/3.11/develop/foxx-microservices/reference/routers/request.md @@ -274,8 +274,7 @@ Gets the value of a header by name. You can validate request headers using the Returns the header value. -is --- +## is `req.is(types): string` diff --git a/site/content/3.11/release-notes/version-3.9/whats-new-in-3-9.md b/site/content/3.11/release-notes/version-3.9/whats-new-in-3-9.md index 66d584cf72..82ccbffb28 100644 --- a/site/content/3.11/release-notes/version-3.9/whats-new-in-3-9.md +++ b/site/content/3.11/release-notes/version-3.9/whats-new-in-3-9.md @@ -117,8 +117,7 @@ Enterprise Edition. See [Optimizing View query performance](../../index-and-search/arangosearch/performance.md) for examples. -UI --- +## UI ### Rebalance Shards for all databases in Web UI diff --git a/site/content/3.12/develop/foxx-microservices/reference/routers/request.md b/site/content/3.12/develop/foxx-microservices/reference/routers/request.md index 96a8ac24bb..721aead75e 100644 --- a/site/content/3.12/develop/foxx-microservices/reference/routers/request.md +++ b/site/content/3.12/develop/foxx-microservices/reference/routers/request.md @@ -274,8 +274,7 @@ Gets the value of a header by name. You can validate request headers using the Returns the header value. -is --- +## is `req.is(types): string` diff --git a/site/content/3.12/release-notes/version-3.9/whats-new-in-3-9.md b/site/content/3.12/release-notes/version-3.9/whats-new-in-3-9.md index 66d584cf72..82ccbffb28 100644 --- a/site/content/3.12/release-notes/version-3.9/whats-new-in-3-9.md +++ b/site/content/3.12/release-notes/version-3.9/whats-new-in-3-9.md @@ -117,8 +117,7 @@ Enterprise Edition. See [Optimizing View query performance](../../index-and-search/arangosearch/performance.md) for examples. -UI --- +## UI ### Rebalance Shards for all databases in Web UI From cce3d633dc860a38a953f433d51922ea996f9c4d Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 18:31:14 +0100 Subject: [PATCH 07/11] Replace intentional double hyphen with en dash --- site/content/3.10/develop/foxx-microservices/getting-started.md | 2 +- site/content/3.11/develop/foxx-microservices/getting-started.md | 2 +- site/content/3.12/develop/foxx-microservices/getting-started.md | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/site/content/3.10/develop/foxx-microservices/getting-started.md b/site/content/3.10/develop/foxx-microservices/getting-started.md index 0cc50a0bd8..bfb1390663 100644 --- a/site/content/3.10/develop/foxx-microservices/getting-started.md +++ b/site/content/3.10/develop/foxx-microservices/getting-started.md @@ -109,7 +109,7 @@ otherwise check out the chapter on [routes](reference/routers/endpoints.md). The object returned by the router's methods provides additional methods to attach metadata and validation to the route. We're using `summary` and -`description` to document what the route does -- these aren't strictly +`description` to document what the route does – these aren't strictly necessary but give us some nice auto-generated documentation. The `response` method lets us additionally document the response content type and what the response body will represent. diff --git a/site/content/3.11/develop/foxx-microservices/getting-started.md b/site/content/3.11/develop/foxx-microservices/getting-started.md index 0cc50a0bd8..bfb1390663 100644 --- a/site/content/3.11/develop/foxx-microservices/getting-started.md +++ b/site/content/3.11/develop/foxx-microservices/getting-started.md @@ -109,7 +109,7 @@ otherwise check out the chapter on [routes](reference/routers/endpoints.md). The object returned by the router's methods provides additional methods to attach metadata and validation to the route. We're using `summary` and -`description` to document what the route does -- these aren't strictly +`description` to document what the route does – these aren't strictly necessary but give us some nice auto-generated documentation. The `response` method lets us additionally document the response content type and what the response body will represent. diff --git a/site/content/3.12/develop/foxx-microservices/getting-started.md b/site/content/3.12/develop/foxx-microservices/getting-started.md index 0cc50a0bd8..bfb1390663 100644 --- a/site/content/3.12/develop/foxx-microservices/getting-started.md +++ b/site/content/3.12/develop/foxx-microservices/getting-started.md @@ -109,7 +109,7 @@ otherwise check out the chapter on [routes](reference/routers/endpoints.md). The object returned by the router's methods provides additional methods to attach metadata and validation to the route. We're using `summary` and -`description` to document what the route does -- these aren't strictly +`description` to document what the route does – these aren't strictly necessary but give us some nice auto-generated documentation. The `response` method lets us additionally document the response content type and what the response body will represent. From e76e63f6f00358c1fc483a02bb3cea6eee31ee5f Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 18:31:27 +0100 Subject: [PATCH 08/11] Add missing code block markup --- .../3.12/index-and-search/arangosearch/wildcard-search.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/site/content/3.12/index-and-search/arangosearch/wildcard-search.md b/site/content/3.12/index-and-search/arangosearch/wildcard-search.md index 95e517deec..17e5515eb2 100644 --- a/site/content/3.12/index-and-search/arangosearch/wildcard-search.md +++ b/site/content/3.12/index-and-search/arangosearch/wildcard-search.md @@ -333,19 +333,23 @@ a space, two hyphens, and another space. {{< tabs "view-definition">}} {{< tab "`search-alias` View" >}} +```aql LET search = "%C_T_ -- %" LET searchNormalized = TOKENS(search, "only_norm")[0] FOR doc IN imdb SEARCH doc.description LIKE searchNormalized RETURN {d: doc.description } +``` {{< /tab >}} {{< tab "`arangosearch` View" >}} +```aql LET search = "%C_T_ -- %" LET searchNormalized = TOKENS(search, "only_norm")[0] FOR doc IN imdb SEARCH ANALYZER(doc.description LIKE searchNormalized, "wildcard_norm") RETURN {d: doc.description } +``` {{< /tab >}} {{< /tabs >}} From 806bfc38f2c3fa9c3685979e4f41642ac6fdd8de Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 18:33:32 +0100 Subject: [PATCH 09/11] Disable automatic typography feature that converts -- to en dash and --- to em dash This interfered with ArangoSearch wildcard Analyzer examples in result tables where the verbatim -- needs to be displayed --- site/config/_default/config.yaml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/site/config/_default/config.yaml b/site/config/_default/config.yaml index 7613469d60..bc53d0d17f 100644 --- a/site/config/_default/config.yaml +++ b/site/config/_default/config.yaml @@ -29,6 +29,12 @@ markup: attribute: block: true title: true + extensions: + typographer: + # The automatic conversion of two hyphens to an en dash interferes with + # search examples using the IMDB dataset (in result tables) + emDash: '---' + enDash: '--' outputFormats: navigation: From 3414edbf9d6d5cb5bedb5fff2826ee2e693b69c2 Mon Sep 17 00:00:00 2001 From: CircleCI Job Date: Tue, 6 Feb 2024 17:45:17 +0000 Subject: [PATCH 10/11] [skip ci] Automatic commit of generated files from CircleCI --- site/data/3.12/cache.json | 82 ++++++++++++++++++++++----------------- 1 file changed, 47 insertions(+), 35 deletions(-) diff --git a/site/data/3.12/cache.json b/site/data/3.12/cache.json index a9d319bb9c..ab8f65ff23 100644 --- a/site/data/3.12/cache.json +++ b/site/data/3.12/cache.json @@ -544,20 +544,20 @@ "response": "eyJpbnB1dCI6IkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpXG5MRVQgciA9IChGT1Iga2V5IElOIGVkZ2VLZXlzIFJFTU9WRSBrZXkgSU4gaW50ZXJuYXRpb25hbEhpZ2h3YXlcbiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9IFJFTU9WRSBrZXkgSU4gZ2VybWFuSGlnaHdheVxuICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5XG4gICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSkgXG5SRU1PVkUgJ0JlcmxpbicgSU4gZ2VybWFuQ2l0eSIsIm91dHB1dCI6IntbR2VuZXJhbEdyYXBoXSBcbiAgXCJmcmVuY2hIaWdod2F5XCIgOiBbQXJhbmdvQ29sbGVjdGlvbiA1OTYsIFwiZnJlbmNoSGlnaHdheVwiICh0eXBlIGVkZ2UsIHN0YXR1cyBsb2FkZWQpXSwgXG4gIFwiZnJlbmNoQ2l0eVwiIDogW0FyYW5nb0NvbGxlY3Rpb24gNTkzLCBcImZyZW5jaENpdHlcIiAodHlwZSBkb2N1bWVudCwgc3RhdHVzIGxvYWRlZCldLCBcbiAgXCJnZXJtYW5IaWdod2F5XCIgOiBbQXJhbmdvQ29sbGVjdGlvbiA1OTUsIFwiZ2VybWFuSGlnaHdheVwiICh0eXBlIGVkZ2UsIHN0YXR1cyBsb2FkZWQpXSwgXG4gIFwiZ2VybWFuQ2l0eVwiIDogW0FyYW5nb0NvbGxlY3Rpb24gNTkyLCBcImdlcm1hbkNpdHlcIiAodHlwZSBkb2N1bWVudCwgc3RhdHVzIGxvYWRlZCldLCBcbiAgXCJpbnRlcm5hdGlvbmFsSGlnaHdheVwiIDogW0FyYW5nb0NvbGxlY3Rpb24gNTk0LCBcImludGVybmF0aW9uYWxIaWdod2F5XCIgKHR5cGUgZWRnZSwgc3RhdHVzIGxvYWRlZCldIFxufVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogMCwgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IkdSQVBIVFJBVl9yZW1vdmVWZXJ0ZXgzIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCIsImRhdGFzZXQiOiJyb3V0ZXBsYW5uZXIifX0K" }, "HttpGharialAddEdgeCol_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2VDb2wKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSI7CmJvZHkgPSB7CiAgY29sbGVjdGlvbjogIndvcmtzX2luIiwKICBmcm9tOiBbImZlbWFsZSIsICJtYWxlIl0sCiAgdG86IFsiY2l0eSJdCn07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", - "response": "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" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2VDb2wKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSI7CmJvZHkgPSB7CiAgY29sbGVjdGlvbjogIndvcmtzX2luIiwKICBmcm9tOiBbImZlbWFsZSIsICJtYWxlIl0sCiAgdG86IFsiY2l0eSJdCn07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "response": "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" }, "HttpGharialAddEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CnJlcXVpcmUoImludGVybmFsIikuZGIuX2Ryb3AoInJlbGF0aW9uIik7CnJlcXVpcmUoImludGVybmFsIikuZGIuX2Ryb3AoImZlbWFsZSIpOwpyZXF1aXJlKCJpbnRlcm5hbCIpLmRiLl9kcm9wKCJtYWxlIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbiI7CmJvZHkgPSB7CiAgdHlwZTogImZyaWVuZCIsCiAgX2Zyb206ICJmZW1hbGUvYWxpY2UiLAogIF90bzogImZlbWFsZS9kaWFuYSIKfTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BPU1QnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb25cbntcbiAgXCJ0eXBlXCI6IFwiZnJpZW5kXCIsXG4gIFwiX2Zyb21cIjogXCJmZW1hbGUvYWxpY2VcIixcbiAgXCJfdG9cIjogXCJmZW1hbGUvZGlhbmFcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogOTRcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfZ28yWGZOYS0tLVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcImVkZ2VcIiA6IHsgXG4gICAgXCJfaWRcIiA6IFwicmVsYXRpb24vNzE5MjJcIiwgXG4gICAgXCJfa2V5XCIgOiBcIjcxOTIyXCIsIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWGZOYS0tLVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEFkZEVkZ2UiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbiI7CmJvZHkgPSB7CiAgdHlwZTogImZyaWVuZCIsCiAgX2Zyb206ICJmZW1hbGUvYWxpY2UiLAogIF90bzogImZlbWFsZS9kaWFuYSIKfTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BPU1QnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb25cbntcbiAgXCJ0eXBlXCI6IFwiZnJpZW5kXCIsXG4gIFwiX2Zyb21cIjogXCJmZW1hbGUvYWxpY2VcIixcbiAgXCJfdG9cIjogXCJmZW1hbGUvZGlhbmFcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogOTRcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaFY3aG9RdS0tQVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcImVkZ2VcIiA6IHsgXG4gICAgXCJfaWRcIiA6IFwicmVsYXRpb24vNzM0MzRcIiwgXG4gICAgXCJfa2V5XCIgOiBcIjczNDM0XCIsIFxuICAgIFwiX3JldlwiIDogXCJfaFY3aG9RdS0tQVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEFkZEVkZ2UiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "HttpGharialAddVertexCol_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZFZlcnRleENvbAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgiOwpib2R5ID0gewogIGNvbGxlY3Rpb246ICJvdGhlclZlcnRpY2VzIgp9Owp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUE9TVCcsIHVybCwgYm9keSk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleFxue1xuICBcImNvbGxlY3Rpb25cIjogXCJvdGhlclZlcnRpY2VzXCJcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDI0NFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9nbzJYYThDLS1fXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZ3JhcGhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcInNvY2lhbFwiLCBcbiAgICBcImVkZ2VEZWZpbml0aW9uc1wiIDogWyBcbiAgICAgIHsgXG4gICAgICAgIFwiY29sbGVjdGlvblwiIDogXCJyZWxhdGlvblwiLCBcbiAgICAgICAgXCJmcm9tXCIgOiBbIFxuICAgICAgICAgIFwiZmVtYWxlXCIsIFxuICAgICAgICAgIFwibWFsZVwiIFxuICAgICAgICBdLCBcbiAgICAgICAgXCJ0b1wiIDogWyBcbiAgICAgICAgICBcImZlbWFsZVwiLCBcbiAgICAgICAgICBcIm1hbGVcIiBcbiAgICAgICAgXSBcbiAgICAgIH0gXG4gICAgXSwgXG4gICAgXCJvcnBoYW5Db2xsZWN0aW9uc1wiIDogWyBcbiAgICAgIFwib3RoZXJWZXJ0aWNlc1wiIFxuICAgIF0sIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWGE4Qy0tX1wiLCBcbiAgICBcIl9pZFwiIDogXCJfZ3JhcGhzL3NvY2lhbFwiLCBcbiAgICBcIm5hbWVcIiA6IFwic29jaWFsXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsQWRkVmVydGV4Q29sIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZFZlcnRleENvbAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgiOwpib2R5ID0gewogIGNvbGxlY3Rpb246ICJvdGhlclZlcnRpY2VzIgp9Owp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUE9TVCcsIHVybCwgYm9keSk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleFxue1xuICBcImNvbGxlY3Rpb25cIjogXCJvdGhlclZlcnRpY2VzXCJcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDI0NFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9oVjdoalhHLS1fXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZ3JhcGhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcInNvY2lhbFwiLCBcbiAgICBcImVkZ2VEZWZpbml0aW9uc1wiIDogWyBcbiAgICAgIHsgXG4gICAgICAgIFwiY29sbGVjdGlvblwiIDogXCJyZWxhdGlvblwiLCBcbiAgICAgICAgXCJmcm9tXCIgOiBbIFxuICAgICAgICAgIFwiZmVtYWxlXCIsIFxuICAgICAgICAgIFwibWFsZVwiIFxuICAgICAgICBdLCBcbiAgICAgICAgXCJ0b1wiIDogWyBcbiAgICAgICAgICBcImZlbWFsZVwiLCBcbiAgICAgICAgICBcIm1hbGVcIiBcbiAgICAgICAgXSBcbiAgICAgIH0gXG4gICAgXSwgXG4gICAgXCJvcnBoYW5Db2xsZWN0aW9uc1wiIDogWyBcbiAgICAgIFwib3RoZXJWZXJ0aWNlc1wiIFxuICAgIF0sIFxuICAgIFwiX3JldlwiIDogXCJfaFY3aGpYRy0tX1wiLCBcbiAgICBcIl9pZFwiIDogXCJfZ3JhcGhzL3NvY2lhbFwiLCBcbiAgICBcIm5hbWVcIiA6IFwic29jaWFsXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsQWRkVmVydGV4Q29sIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialAddVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZFZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvbWFsZSI7CmJvZHkgPSB7CiAgbmFtZTogIkZyYW5jaXMiCn0KdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BPU1QnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9tYWxlXG57XG4gIFwibmFtZVwiOiBcIkZyYW5jaXNcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogOTJcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfZ28yWGVFTy0tQVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJtYWxlLzcxNDIxXCIsIFxuICAgIFwiX2tleVwiIDogXCI3MTQyMVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2dvMlhlRU8tLUFcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxBZGRWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZFZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvbWFsZSI7CmJvZHkgPSB7CiAgbmFtZTogIkZyYW5jaXMiCn0KdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BPU1QnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9tYWxlXG57XG4gIFwibmFtZVwiOiBcIkZyYW5jaXNcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogOTJcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaFY3aG40Ni0tX1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJtYWxlLzcyNzU3XCIsIFxuICAgIFwiX2tleVwiIDogXCI3Mjc1N1wiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2hWN2huNDYtLV9cIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxBZGRWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "HttpGharialCreateDisjointSmart_single": { "request": "LS0tCmRlc2NyaXB0aW9uOiB8LQogIENyZWF0ZSBhIGRpc2pvaW50IFNtYXJ0R3JhcGguIFRoaXMgZ3JhcGggdXNlcyA5IHNoYXJkcyBhbmQKICBpcyBzaGFyZGVkIGJ5IHRoZSAicmVnaW9uIiBhdHRyaWJ1dGUuCiAgQXZhaWxhYmxlIGluIHRoZSBFbnRlcnByaXNlIEVkaXRpb24gb25seS4KICBOb3RlIHRoYXQgYXMgeW91IGFyZSB1c2luZyBhIGRpc2pvaW50IHZlcnNpb24sIHlvdSBjYW4gb25seQogIGNyZWF0ZSBlZGdlcyBiZXR3ZWVuIHZlcnRpY2VzIHNoYXJpbmcgdGhlIHNhbWUgcmVnaW9uLgpuYW1lOiBIdHRwR2hhcmlhbENyZWF0ZURpc2pvaW50U21hcnQKLS0tCnZhciBncmFwaCA9IHJlcXVpcmUoIkBhcmFuZ29kYi9nZW5lcmFsLWdyYXBoIik7CiBpZiAoZ3JhcGguX2V4aXN0cygiZGlzam9pbnRTbWFydEdyYXBoIikpIHsKICAgIGdyYXBoLl9kcm9wKCJkaXNqb2ludFNtYXJ0R3JhcGgiLCB0cnVlKTsKfQp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwiOwpib2R5ID0gewpuYW1lOiAiZGlzam9pbnRTbWFydEdyYXBoIiwKZWRnZURlZmluaXRpb25zOiBbewpjb2xsZWN0aW9uOiAiZWRnZXMiLApmcm9tOiBbICJzdGFydFZlcnRpY2VzIiBdLAp0bzogWyAiZW5kVmVydGljZXMiIF0KfV0sCm9ycGhhbkNvbGxlY3Rpb25zOiBbICJvcnBoYW5WZXJ0aWNlcyIgXSwKaXNTbWFydDogdHJ1ZSwKb3B0aW9uczogewppc0Rpc2pvaW50OiB0cnVlLApyZXBsaWNhdGlvbkZhY3RvcjogMiwKbnVtYmVyT2ZTaGFyZHM6IDksCnNtYXJ0R3JhcGhBdHRyaWJ1dGU6ICJyZWdpb24iCn0KfTsKCnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKCmdyYXBoLl9kcm9wKCJkaXNqb2ludFNtYXJ0R3JhcGgiLCB0cnVlKTs=", @@ -584,72 +584,72 @@ "response": "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" }, "HttpGharialDeleteEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERlbGV0ZUVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24vNzI0NTAiLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDQxXG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInJlbW92ZWRcIiA6IHRydWUgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsRGVsZXRlRWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERlbGV0ZUVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24vNzQwNzAiLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDQxXG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInJlbW92ZWRcIiA6IHRydWUgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsRGVsZXRlRWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "HttpGharialDeleteVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERlbGV0ZVZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERlbGV0ZVZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9mZW1hbGUvYWxpY2UiLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDQxXG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInJlbW92ZWRcIiA6IHRydWUgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsRGVsZXRlVmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialDrop_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERyb3AKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWw/ZHJvcENvbGxlY3Rpb25zPXRydWUiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnREVMRVRFJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbERyb3AKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWw/ZHJvcENvbGxlY3Rpb25zPXRydWUiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnREVMRVRFJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsP2Ryb3BDb2xsZWN0aW9ucz10cnVlIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiA0MVxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAyLCBcbiAgXCJyZW1vdmVkXCIgOiB0cnVlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbERyb3AiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "HttpGharialEdgeDefinitionRemove_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEVkZ2VEZWZpbml0aW9uUmVtb3ZlCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnREVMRVRFJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZGIuX2Ryb3AoInJlbGF0aW9uIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDE3MVxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9nbzJYZDB5LS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZ3JhcGhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcInNvY2lhbFwiLCBcbiAgICBcImVkZ2VEZWZpbml0aW9uc1wiIDogWyBdLCBcbiAgICBcIm9ycGhhbkNvbGxlY3Rpb25zXCIgOiBbIFxuICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICBcIm1hbGVcIiBcbiAgICBdLCBcbiAgICBcIl9yZXZcIiA6IFwiX2dvMlhkMHktLS1cIiwgXG4gICAgXCJfaWRcIiA6IFwiX2dyYXBocy9zb2NpYWxcIiwgXG4gICAgXCJuYW1lXCIgOiBcInNvY2lhbFwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEVkZ2VEZWZpbml0aW9uUmVtb3ZlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEVkZ2VEZWZpbml0aW9uUmVtb3ZlCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnREVMRVRFJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZGIuX2Ryb3AoInJlbGF0aW9uIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDE3MVxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9oVjdobnYyLS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZ3JhcGhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcInNvY2lhbFwiLCBcbiAgICBcImVkZ2VEZWZpbml0aW9uc1wiIDogWyBdLCBcbiAgICBcIm9ycGhhbkNvbGxlY3Rpb25zXCIgOiBbIFxuICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICBcIm1hbGVcIiBcbiAgICBdLCBcbiAgICBcIl9yZXZcIiA6IFwiX2hWN2hudjItLS1cIiwgXG4gICAgXCJfaWRcIiA6IFwiX2dyYXBocy9zb2NpYWxcIiwgXG4gICAgXCJuYW1lXCIgOiBcInNvY2lhbFwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEVkZ2VEZWZpbml0aW9uUmVtb3ZlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialGetEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEdldEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbi83MjAzNCIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTcwXG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2dvMlhmYVMtLUNcbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAwLCBcbiAgXCJlZGdlXCIgOiB7IFxuICAgIFwiX2tleVwiIDogXCI3MjAzNFwiLCBcbiAgICBcIl9pZFwiIDogXCJyZWxhdGlvbi83MjAzNFwiLCBcbiAgICBcIl9mcm9tXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl90b1wiIDogXCJtYWxlL2NoYXJseVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2dvMlhmYVMtLUNcIiwgXG4gICAgXCJ0eXBlXCIgOiBcImZyaWVuZFwiLCBcbiAgICBcInZlcnRleFwiIDogXCJhbGljZVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEdldEVkZ2UiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEdldEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbi83MzUzMSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTY1XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2hWN2hvVDYtLS1cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAwLCBcbiAgXCJlZGdlXCIgOiB7IFxuICAgIFwiX2tleVwiIDogXCI3MzUzMVwiLCBcbiAgICBcIl9pZFwiIDogXCJyZWxhdGlvbi83MzUzMVwiLCBcbiAgICBcIl9mcm9tXCIgOiBcIm1hbGUvYm9iXCIsIFxuICAgIFwiX3RvXCIgOiBcImZlbWFsZS9kaWFuYVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2hWN2hvVDYtLS1cIiwgXG4gICAgXCJ0eXBlXCIgOiBcImZyaWVuZFwiLCBcbiAgICBcInZlcnRleFwiIDogXCJib2JcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxHZXRFZGdlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialGetGraph_single": { "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEdldEdyYXBoCi0tLQp2YXIgZ3JhcGggPSByZXF1aXJlKCJAYXJhbmdvZGIvZ2VuZXJhbC1ncmFwaCIpOwppZiAoZ3JhcGguX2V4aXN0cygibXlHcmFwaCIpKSB7CiAgZ3JhcGguX2Ryb3AoIm15R3JhcGgiLCB0cnVlKTsKfQpncmFwaC5fY3JlYXRlKCJteUdyYXBoIiwgW3sKICBjb2xsZWN0aW9uOiAiZWRnZXMiLAogIGZyb206IFsgInN0YXJ0VmVydGljZXMiIF0sCiAgdG86IFsgImVuZFZlcnRpY2VzIiBdCn1dKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL215R3JhcGgiOwoKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CgpncmFwaC5fZHJvcCgibXlHcmFwaCIsIHRydWUpOw==", "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9teUdyYXBoIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAwIE9LXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAyMjdcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMCwgXG4gIFwiZ3JhcGhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcIm15R3JhcGhcIiwgXG4gICAgXCJlZGdlRGVmaW5pdGlvbnNcIiA6IFsgXG4gICAgICB7IFxuICAgICAgICBcImNvbGxlY3Rpb25cIiA6IFwiZWRnZXNcIiwgXG4gICAgICAgIFwiZnJvbVwiIDogWyBcbiAgICAgICAgICBcInN0YXJ0VmVydGljZXNcIiBcbiAgICAgICAgXSwgXG4gICAgICAgIFwidG9cIiA6IFsgXG4gICAgICAgICAgXCJlbmRWZXJ0aWNlc1wiIFxuICAgICAgICBdIFxuICAgICAgfSBcbiAgICBdLCBcbiAgICBcIm9ycGhhbkNvbGxlY3Rpb25zXCIgOiBbIF0sIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWFg4YS0tX1wiLCBcbiAgICBcIl9pZFwiIDogXCJfZ3JhcGhzL215R3JhcGhcIiwgXG4gICAgXCJuYW1lXCIgOiBcIm15R3JhcGhcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxHZXRHcmFwaCIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "HttpGharialGetVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEdldFZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTA5XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2dvMlhlU2EtLS1cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAwLCBcbiAgXCJ2ZXJ0ZXhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX2lkXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2dvMlhlU2EtLS1cIiwgXG4gICAgXCJuYW1lXCIgOiBcIkFsaWNlXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsR2V0VmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEdldFZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTA5XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2hWN2hvX2ktLS1cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAwLCBcbiAgXCJ2ZXJ0ZXhcIiA6IHsgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX2lkXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2hWN2hvX2ktLS1cIiwgXG4gICAgXCJuYW1lXCIgOiBcIkFsaWNlXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsR2V0VmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialListEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3RFZGdlCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3RFZGdlCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogNTNcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMCwgXG4gIFwiY29sbGVjdGlvbnNcIiA6IFsgXG4gICAgXCJyZWxhdGlvblwiIFxuICBdIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbExpc3RFZGdlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialListVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3RWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4IjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3RWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4IjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4Iiwib3V0cHV0IjoiSFRUUC8xLjEgMjAwIE9LXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiA1OFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAwLCBcbiAgXCJjb2xsZWN0aW9uc1wiIDogWyBcbiAgICBcImZlbWFsZVwiLCBcbiAgICBcIm1hbGVcIiBcbiAgXSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxMaXN0VmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialList_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3QKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgicm91dGVwbGFubmVyIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbCI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdHRVQnLCB1cmwpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOwpleGFtcGxlcy5kcm9wR3JhcGgoInJvdXRlcGxhbm5lciIpOw==", - "response": "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" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbExpc3QKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgicm91dGVwbGFubmVyIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbCI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdHRVQnLCB1cmwpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOwpleGFtcGxlcy5kcm9wR3JhcGgoInJvdXRlcGxhbm5lciIpOw==", + "response": "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" }, "HttpGharialModifyVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbE1vZGlmeVZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKYm9keSA9IHsKICBhZ2U6IDI2Cn0KdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BBVENIJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUEFUQ0ggLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kYXRhLWJpbmFyeSBALSAtLWR1bXAgLSBodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlXG57XG4gIFwiYWdlXCI6IDI2XG59Iiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMThcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfZ28yWGVncS0tX1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJmZW1hbGUvYWxpY2VcIiwgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX29sZFJldlwiIDogXCJfZ28yWGVnaS0tLVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2dvMlhlZ3EtLV9cIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxNb2RpZnlWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbE1vZGlmeVZlcnRleAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKYm9keSA9IHsKICBhZ2U6IDI2Cn0KdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ1BBVENIJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUEFUQ0ggLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kYXRhLWJpbmFyeSBALSAtLWR1bXAgLSBodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9naGFyaWFsL3NvY2lhbC92ZXJ0ZXgvZmVtYWxlL2FsaWNlXG57XG4gIFwiYWdlXCI6IDI2XG59Iiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMThcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaFY3aG9DNi0tX1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJmZW1hbGUvYWxpY2VcIiwgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX29sZFJldlwiIDogXCJfaFY3aG9DeS0tX1wiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2hWN2hvQzYtLV9cIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxNb2RpZnlWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "HttpGharialPatchEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFBhdGNoRWRnZQotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIGFueSA9IHJlcXVpcmUoIkBhcmFuZ29kYiIpLmRiLnJlbGF0aW9uLmFueSgpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24vIiArIGFueS5fa2V5Owpib2R5ID0gewogIHNpbmNlOiAiMDEuMDEuMjAwMSIKfQp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUEFUQ0gnLCB1cmwsIGJvZHkpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUEFUQ0ggLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kYXRhLWJpbmFyeSBALSAtLWR1bXAgLSBodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLzcyMTUzXG57XG4gIFwic2luY2VcIjogXCIwMS4wMS4yMDAxXCJcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDExOFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9nbzJYZm8yLS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZWRnZVwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJyZWxhdGlvbi83MjE1M1wiLCBcbiAgICBcIl9rZXlcIiA6IFwiNzIxNTNcIiwgXG4gICAgXCJfb2xkUmV2XCIgOiBcIl9nbzJYZm91LS1DXCIsIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWGZvMi0tLVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbFBhdGNoRWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFBhdGNoRWRnZQotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKdmFyIGFueSA9IHJlcXVpcmUoIkBhcmFuZ29kYiIpLmRiLnJlbGF0aW9uLmFueSgpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24vIiArIGFueS5fa2V5Owpib2R5ID0gewogIHNpbmNlOiAiMDEuMDEuMjAwMSIKfQp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUEFUQ0gnLCB1cmwsIGJvZHkpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUEFUQ0ggLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kYXRhLWJpbmFyeSBALSAtLWR1bXAgLSBodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLzczNjQxXG57XG4gIFwic2luY2VcIjogXCIwMS4wMS4yMDAxXCJcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDExOFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9oVjdocFhhLS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwiZWRnZVwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJyZWxhdGlvbi83MzY0MVwiLCBcbiAgICBcIl9rZXlcIiA6IFwiNzM2NDFcIiwgXG4gICAgXCJfb2xkUmV2XCIgOiBcIl9oVjdocFhTLS1fXCIsIFxuICAgIFwiX3JldlwiIDogXCJfaFY3aHBYYS0tLVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbFBhdGNoRWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "HttpGharialPutEdge_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFB1dEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKYm9keSA9IHsKICB0eXBlOiAiZGl2b3JjZWQiLAogIF9mcm9tOiAiZmVtYWxlL2FsaWNlIiwKICBfdG86ICJtYWxlL2JvYiIKfQp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUFVUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbi83MjI5MVxue1xuICBcInR5cGVcIjogXCJkaXZvcmNlZFwiLFxuICBcIl9mcm9tXCI6IFwiZmVtYWxlL2FsaWNlXCIsXG4gIFwiX3RvXCI6IFwibWFsZS9ib2JcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTE4XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2dvMlhncjYtLS1cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAyLCBcbiAgXCJlZGdlXCIgOiB7IFxuICAgIFwiX2lkXCIgOiBcInJlbGF0aW9uLzcyMjkxXCIsIFxuICAgIFwiX2tleVwiIDogXCI3MjI5MVwiLCBcbiAgICBcIl9vbGRSZXZcIiA6IFwiX2dvMlhncnktLUJcIiwgXG4gICAgXCJfcmV2XCIgOiBcIl9nbzJYZ3I2LS0tXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsUHV0RWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFB1dEVkZ2UKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciBhbnkgPSByZXF1aXJlKCJAYXJhbmdvZGIiKS5kYi5yZWxhdGlvbi5hbnkoKTsKdmFyIHVybCA9ICIvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlL3JlbGF0aW9uLyIgKyBhbnkuX2tleTsKYm9keSA9IHsKICB0eXBlOiAiZGl2b3JjZWQiLAogIF9mcm9tOiAiZmVtYWxlL2FsaWNlIiwKICBfdG86ICJtYWxlL2JvYiIKfQp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUFVUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvbi83Mzg1MVxue1xuICBcInR5cGVcIjogXCJkaXZvcmNlZFwiLFxuICBcIl9mcm9tXCI6IFwiZmVtYWxlL2FsaWNlXCIsXG4gIFwiX3RvXCI6IFwibWFsZS9ib2JcIlxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTE4XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2hWN2hwZHEtLV9cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAyLCBcbiAgXCJlZGdlXCIgOiB7IFxuICAgIFwiX2lkXCIgOiBcInJlbGF0aW9uLzczODUxXCIsIFxuICAgIFwiX2tleVwiIDogXCI3Mzg1MVwiLCBcbiAgICBcIl9vbGRSZXZcIiA6IFwiX2hWN2hwZG0tLUJcIiwgXG4gICAgXCJfcmV2XCIgOiBcIl9oVjdocGRxLS1fXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsUHV0RWRnZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "HttpGharialRemoveVertexCollectionFailed_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiB8LQogIFlvdSBjYW5ub3QgcmVtb3ZlIHZlcnRleCBjb2xsZWN0aW9ucyB0aGF0IGFyZSB1c2VkIGluIGVkZ2UgZGVmaW5pdGlvbnM6Cm5hbWU6IEh0dHBHaGFyaWFsUmVtb3ZlVmVydGV4Q29sbGVjdGlvbkZhaWxlZAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTsKdmFyIGcgPSBleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9tYWxlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gNDAwKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmRiLl9kcm9wKCJtYWxlIik7CmRiLl9kcm9wKCJmZW1hbGUiKTsKZGIuX2Ryb3AoInJlbGF0aW9uIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7", + "request": "LS0tCmRlc2NyaXB0aW9uOiB8LQogIFlvdSBjYW5ub3QgcmVtb3ZlIHZlcnRleCBjb2xsZWN0aW9ucyB0aGF0IGFyZSB1c2VkIGluIGVkZ2UgZGVmaW5pdGlvbnM6Cm5hbWU6IEh0dHBHaGFyaWFsUmVtb3ZlVmVydGV4Q29sbGVjdGlvbkZhaWxlZAotLS0KdmFyIGV4YW1wbGVzID0gcmVxdWlyZSgiQGFyYW5nb2RiL2dyYXBoLWV4YW1wbGVzL2V4YW1wbGUtZ3JhcGguanMiKTsKdmFyIGcgPSBleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9tYWxlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7IC8vIHhwRXJyb3IoRVJST1JfR1JBUEhfTk9UX0lOX09SUEhBTl9DT0xMRUNUSU9OKQoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDQwMCk7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9tYWxlIiwib3V0cHV0IjoiSFRUUC8xLjEgNDAwIEJhZCBSZXF1ZXN0XG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMDZcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJjb2RlXCIgOiA0MDAsIFxuICBcImVycm9yXCIgOiB0cnVlLCBcbiAgXCJlcnJvck1lc3NhZ2VcIiA6IFwiY29sbGVjdGlvbiBpcyBub3QgaW4gbGlzdCBvZiBvcnBoYW4gY29sbGVjdGlvbnNcIiwgXG4gIFwiZXJyb3JOdW1cIiA6IDE5MjggXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiWW91IGNhbm5vdCByZW1vdmUgdmVydGV4IGNvbGxlY3Rpb25zIHRoYXQgYXJlIHVzZWQgaW4gZWRnZSBkZWZpbml0aW9uczoiLCJuYW1lIjoiSHR0cEdoYXJpYWxSZW1vdmVWZXJ0ZXhDb2xsZWN0aW9uRmFpbGVkIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialRemoveVertexCollection_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiB8LQogIFlvdSBjYW4gcmVtb3ZlIHZlcnRleCBjb2xsZWN0aW9ucyB0aGF0IGFyZSBub3QgdXNlZCBpbiBhbnkgZWRnZSBkZWZpbml0aW9uOgpuYW1lOiBIdHRwR2hhcmlhbFJlbW92ZVZlcnRleENvbGxlY3Rpb24KLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CnZhciBnID0gZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKZy5fYWRkVmVydGV4Q29sbGVjdGlvbigib3RoZXJWZXJ0aWNlcyIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9vdGhlclZlcnRpY2VzIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmRiLl9kcm9wKCJvdGhlclZlcnRpY2VzIik7", - "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9vdGhlclZlcnRpY2VzIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAyMjlcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaEZ3VEhqQy0tLVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcImdyYXBoXCIgOiB7IFxuICAgIFwiX2tleVwiIDogXCJzb2NpYWxcIiwgXG4gICAgXCJlZGdlRGVmaW5pdGlvbnNcIiA6IFsgXG4gICAgICB7IFxuICAgICAgICBcImNvbGxlY3Rpb25cIiA6IFwicmVsYXRpb25cIiwgXG4gICAgICAgIFwiZnJvbVwiIDogWyBcbiAgICAgICAgICBcImZlbWFsZVwiLCBcbiAgICAgICAgICBcIm1hbGVcIiBcbiAgICAgICAgXSwgXG4gICAgICAgIFwidG9cIiA6IFsgXG4gICAgICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICAgICAgXCJtYWxlXCIgXG4gICAgICAgIF0gXG4gICAgICB9IFxuICAgIF0sIFxuICAgIFwib3JwaGFuQ29sbGVjdGlvbnNcIiA6IFsgXSwgXG4gICAgXCJfcmV2XCIgOiBcIl9oRndUSGpDLS0tXCIsIFxuICAgIFwiX2lkXCIgOiBcIl9ncmFwaHMvc29jaWFsXCIsIFxuICAgIFwibmFtZVwiIDogXCJzb2NpYWxcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiJZb3UgY2FuIHJlbW92ZSB2ZXJ0ZXggY29sbGVjdGlvbnMgdGhhdCBhcmUgbm90IHVzZWQgaW4gYW55IGVkZ2UgZGVmaW5pdGlvbjoiLCJuYW1lIjoiSHR0cEdoYXJpYWxSZW1vdmVWZXJ0ZXhDb2xsZWN0aW9uIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCmRlc2NyaXB0aW9uOiB8LQogIFlvdSBjYW4gcmVtb3ZlIHZlcnRleCBjb2xsZWN0aW9ucyB0aGF0IGFyZSBub3QgdXNlZCBpbiBhbnkgZWRnZSBkZWZpbml0aW9uOgpuYW1lOiBIdHRwR2hhcmlhbFJlbW92ZVZlcnRleENvbGxlY3Rpb24KLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CnZhciBnID0gZXhhbXBsZXMubG9hZEdyYXBoKCJzb2NpYWwiKTsKZy5fYWRkVmVydGV4Q29sbGVjdGlvbigib3RoZXJWZXJ0aWNlcyIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9vdGhlclZlcnRpY2VzIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7Cgphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAyKTsKCmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmRiLl9kcm9wKCJvdGhlclZlcnRpY2VzIik7", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtIGh0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9vdGhlclZlcnRpY2VzIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAyMjlcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaFY3aGpmLS0tLVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcImdyYXBoXCIgOiB7IFxuICAgIFwiX2tleVwiIDogXCJzb2NpYWxcIiwgXG4gICAgXCJlZGdlRGVmaW5pdGlvbnNcIiA6IFsgXG4gICAgICB7IFxuICAgICAgICBcImNvbGxlY3Rpb25cIiA6IFwicmVsYXRpb25cIiwgXG4gICAgICAgIFwiZnJvbVwiIDogWyBcbiAgICAgICAgICBcImZlbWFsZVwiLCBcbiAgICAgICAgICBcIm1hbGVcIiBcbiAgICAgICAgXSwgXG4gICAgICAgIFwidG9cIiA6IFsgXG4gICAgICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICAgICAgXCJtYWxlXCIgXG4gICAgICAgIF0gXG4gICAgICB9IFxuICAgIF0sIFxuICAgIFwib3JwaGFuQ29sbGVjdGlvbnNcIiA6IFsgXSwgXG4gICAgXCJfcmV2XCIgOiBcIl9oVjdoamYtLS0tXCIsIFxuICAgIFwiX2lkXCIgOiBcIl9ncmFwaHMvc29jaWFsXCIsIFxuICAgIFwibmFtZVwiIDogXCJzb2NpYWxcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiJZb3UgY2FuIHJlbW92ZSB2ZXJ0ZXggY29sbGVjdGlvbnMgdGhhdCBhcmUgbm90IHVzZWQgaW4gYW55IGVkZ2UgZGVmaW5pdGlvbjoiLCJuYW1lIjoiSHR0cEdoYXJpYWxSZW1vdmVWZXJ0ZXhDb2xsZWN0aW9uIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, "HttpGharialReplaceEdgeCol_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VFZGdlQ29sCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iOwpib2R5ID0gewogIGNvbGxlY3Rpb246ICJyZWxhdGlvbiIsCiAgZnJvbTogWyJmZW1hbGUiLCAibWFsZSIsICJhbmltYWwiXSwKICB0bzogWyJmZW1hbGUiLCAibWFsZSIsICJhbmltYWwiXQp9Owp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUFVUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvblxue1xuICBcImNvbGxlY3Rpb25cIjogXCJyZWxhdGlvblwiLFxuICBcImZyb21cIjogW1xuICAgIFwiZmVtYWxlXCIsXG4gICAgXCJtYWxlXCIsXG4gICAgXCJhbmltYWxcIlxuICBdLFxuICBcInRvXCI6IFtcbiAgICBcImZlbWFsZVwiLFxuICAgIFwibWFsZVwiLFxuICAgIFwiYW5pbWFsXCJcbiAgXVxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMjQ3XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2dvMlhkbi0tLV9cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAyLCBcbiAgXCJncmFwaFwiIDogeyBcbiAgICBcIl9rZXlcIiA6IFwic29jaWFsXCIsIFxuICAgIFwiZWRnZURlZmluaXRpb25zXCIgOiBbIFxuICAgICAgeyBcbiAgICAgICAgXCJjb2xsZWN0aW9uXCIgOiBcInJlbGF0aW9uXCIsIFxuICAgICAgICBcImZyb21cIiA6IFsgXG4gICAgICAgICAgXCJhbmltYWxcIiwgXG4gICAgICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICAgICAgXCJtYWxlXCIgXG4gICAgICAgIF0sIFxuICAgICAgICBcInRvXCIgOiBbIFxuICAgICAgICAgIFwiYW5pbWFsXCIsIFxuICAgICAgICAgIFwiZmVtYWxlXCIsIFxuICAgICAgICAgIFwibWFsZVwiIFxuICAgICAgICBdIFxuICAgICAgfSBcbiAgICBdLCBcbiAgICBcIm9ycGhhbkNvbGxlY3Rpb25zXCIgOiBbIF0sIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWGRuLS0tX1wiLCBcbiAgICBcIl9pZFwiIDogXCJfZ3JhcGhzL3NvY2lhbFwiLCBcbiAgICBcIm5hbWVcIiA6IFwic29jaWFsXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsUmVwbGFjZUVkZ2VDb2wiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VFZGdlQ29sCi0tLQp2YXIgZXhhbXBsZXMgPSByZXF1aXJlKCJAYXJhbmdvZGIvZ3JhcGgtZXhhbXBsZXMvZXhhbXBsZS1ncmFwaC5qcyIpOwpleGFtcGxlcy5sb2FkR3JhcGgoInNvY2lhbCIpOwp2YXIgdXJsID0gIi9fYXBpL2doYXJpYWwvc29jaWFsL2VkZ2UvcmVsYXRpb24iOwpib2R5ID0gewogIGNvbGxlY3Rpb246ICJyZWxhdGlvbiIsCiAgZnJvbTogWyJmZW1hbGUiLCAibWFsZSIsICJhbmltYWwiXSwKICB0bzogWyJmZW1hbGUiLCAibWFsZSIsICJhbmltYWwiXQp9Owp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnUFVUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZS9yZWxhdGlvblxue1xuICBcImNvbGxlY3Rpb25cIjogXCJyZWxhdGlvblwiLFxuICBcImZyb21cIjogW1xuICAgIFwiZmVtYWxlXCIsXG4gICAgXCJtYWxlXCIsXG4gICAgXCJhbmltYWxcIlxuICBdLFxuICBcInRvXCI6IFtcbiAgICBcImZlbWFsZVwiLFxuICAgIFwibWFsZVwiLFxuICAgIFwiYW5pbWFsXCJcbiAgXVxufSIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMiBBY2NlcHRlZFxuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMjQ3XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXRhZzogX2hWN2huczYtLV9cbmV4cGlyZXM6IDBcbnByYWdtYTogbm8tY2FjaGVcbnNlcnZlcjogQXJhbmdvREJcbnN0cmljdC10cmFuc3BvcnQtc2VjdXJpdHk6IG1heC1hZ2U9MzE1MzYwMDAgOyBpbmNsdWRlU3ViRG9tYWluc1xueC1hcmFuZ28tcXVldWUtdGltZS1zZWNvbmRzOiAwLjAwMDAwMFxueC1jb250ZW50LXR5cGUtb3B0aW9uczogbm9zbmlmZlxuXG57IFxuICBcImVycm9yXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAyLCBcbiAgXCJncmFwaFwiIDogeyBcbiAgICBcIl9rZXlcIiA6IFwic29jaWFsXCIsIFxuICAgIFwiZWRnZURlZmluaXRpb25zXCIgOiBbIFxuICAgICAgeyBcbiAgICAgICAgXCJjb2xsZWN0aW9uXCIgOiBcInJlbGF0aW9uXCIsIFxuICAgICAgICBcImZyb21cIiA6IFsgXG4gICAgICAgICAgXCJhbmltYWxcIiwgXG4gICAgICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICAgICAgXCJtYWxlXCIgXG4gICAgICAgIF0sIFxuICAgICAgICBcInRvXCIgOiBbIFxuICAgICAgICAgIFwiYW5pbWFsXCIsIFxuICAgICAgICAgIFwiZmVtYWxlXCIsIFxuICAgICAgICAgIFwibWFsZVwiIFxuICAgICAgICBdIFxuICAgICAgfSBcbiAgICBdLCBcbiAgICBcIm9ycGhhbkNvbGxlY3Rpb25zXCIgOiBbIF0sIFxuICAgIFwiX3JldlwiIDogXCJfaFY3aG5zNi0tX1wiLCBcbiAgICBcIl9pZFwiIDogXCJfZ3JhcGhzL3NvY2lhbFwiLCBcbiAgICBcIm5hbWVcIiA6IFwic29jaWFsXCIgXG4gIH0gXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6Ikh0dHBHaGFyaWFsUmVwbGFjZUVkZ2VDb2wiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "HttpGharialReplaceVertex_single": { - "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmRyb3BHcmFwaCgic29jaWFsIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmJvZHkgPSB7CiAgbmFtZTogIkFsaWNlIENvb3BlciIsCiAgYWdlOiAyNgp9CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", - "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZVxue1xuICBcIm5hbWVcIjogXCJBbGljZSBDb29wZXJcIixcbiAgXCJhZ2VcIjogMjZcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDExOFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9nbzJYZXZtLS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwidmVydGV4XCIgOiB7IFxuICAgIFwiX2lkXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl9rZXlcIiA6IFwiYWxpY2VcIiwgXG4gICAgXCJfb2xkUmV2XCIgOiBcIl9nbzJYZXZhLS0tXCIsIFxuICAgIFwiX3JldlwiIDogXCJfZ28yWGV2bS0tLVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmJvZHkgPSB7CiAgbmFtZTogIkFsaWNlIENvb3BlciIsCiAgYWdlOiAyNgp9CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZVxue1xuICBcIm5hbWVcIjogXCJBbGljZSBDb29wZXJcIixcbiAgXCJhZ2VcIjogMjZcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDExOFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9oVjdob0h5LS0tXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwidmVydGV4XCIgOiB7IFxuICAgIFwiX2lkXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl9rZXlcIiA6IFwiYWxpY2VcIiwgXG4gICAgXCJfb2xkUmV2XCIgOiBcIl9oVjdob0hxLS0tXCIsIFxuICAgIFwiX3JldlwiIDogXCJfaFY3aG9IeS0tLVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, "IndexIdentifier_single": { "request": "LS0tCm5hbWU6IEluZGV4SWRlbnRpZmllcgpkZXNjcmlwdGlvbjogJycKLS0tCn5kYi5fY3JlYXRlKCJleGFtcGxlIik7CmRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyAiYSIsICJiIiBdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5nZXRJbmRleGVzKCkubWFwKGZ1bmN0aW9uKHgpIHsgcmV0dXJuIHguaWQ7IH0pOwppbmRleEluZm87CmRiLl9pbmRleChpbmRleEluZm9bMF0pCmRiLl9pbmRleChpbmRleEluZm9bMV0pCn5kYi5fZHJvcCgiZXhhbXBsZSIpOw==", @@ -1771,6 +1771,18 @@ "request": "LS0tCm5hbWU6IGFuYWx5emVyVHlwZQpkZXNjcmlwdGlvbjogJycKLS0tCnZhciBhbmFseXplcnMgPSByZXF1aXJlKCJAYXJhbmdvZGIvYW5hbHl6ZXJzIik7CmFuYWx5emVycy5hbmFseXplcigidGV4dF9lbiIpLnR5cGUoKTs=", "response": "eyJpbnB1dCI6InZhciBhbmFseXplcnMgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FuYWx5emVyc1wiKTtcbmFuYWx5emVycy5hbmFseXplcihcInRleHRfZW5cIikudHlwZSgpOyIsIm91dHB1dCI6InRleHQiLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiYW5hbHl6ZXJUeXBlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, + "analyzerWildcard1_single": { + "request": "LS0tCm5hbWU6IGFuYWx5emVyV2lsZGNhcmQxCmRlc2NyaXB0aW9uOiB8CiAgQ3JlYXRlIGEgYHdpbGRjYXJkYCBBbmFseXplciB3aXRoIGFuIF9uXy1ncmFtIHNpemUgb2YgNCBhbmQgd2l0aG91dCBlbmFibGluZwogIEFuYWx5emVyIGZlYXR1cmVzOgotLS0KdmFyIGFuYWx5emVycyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hbmFseXplcnMiKTsKdmFyIGFuYWx5emVyV2lsZGNhcmQgPSBhbmFseXplcnMuc2F2ZSgid2lsZGNhcmRfNCIsICJ3aWxkY2FyZCIsIHsgbmdyYW1TaXplOiA0IH0sIFtdKTsKCmRiLl9xdWVyeShgUkVUVVJOIFRPS0VOUygiVGhlIHF1aWNrIGJyb3duIEZveHgiLCAid2lsZGNhcmRfNCIpYCkudG9BcnJheSgpOwp+YW5hbHl6ZXJzLnJlbW92ZShhbmFseXplcldpbGRjYXJkLm5hbWUpOw==", + "response": "eyJpbnB1dCI6InZhciBhbmFseXplcnMgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FuYWx5emVyc1wiKTtcbnZhciBhbmFseXplcldpbGRjYXJkID0gYW5hbHl6ZXJzLnNhdmUoXCJ3aWxkY2FyZF80XCIsIFwid2lsZGNhcmRcIiwgeyBuZ3JhbVNpemU6IDQgfSwgW10pO1xuXG5kYi5fcXVlcnkoYFJFVFVSTiBUT0tFTlMoXCJUaGUgcXVpY2sgYnJvd24gRm94eFwiLCBcIndpbGRjYXJkXzRcIilgKS50b0FycmF5KCk7Iiwib3V0cHV0IjoiWyBcbiAgWyBcbiAgICBcIu+/vVRoZVwiLCBcbiAgICBcIlRoZSBcIiwgXG4gICAgXCJoZSBxXCIsIFxuICAgIFwiZSBxdVwiLCBcbiAgICBcIiBxdWlcIiwgXG4gICAgXCJxdWljXCIsIFxuICAgIFwidWlja1wiLCBcbiAgICBcImljayBcIiwgXG4gICAgXCJjayBiXCIsIFxuICAgIFwiayBiclwiLCBcbiAgICBcIiBicm9cIiwgXG4gICAgXCJicm93XCIsIFxuICAgIFwicm93blwiLCBcbiAgICBcIm93biBcIiwgXG4gICAgXCJ3biBGXCIsIFxuICAgIFwibiBGb1wiLCBcbiAgICBcIiBGb3hcIiwgXG4gICAgXCJGb3h4XCIsIFxuICAgIFwib3h477+9XCIsIFxuICAgIFwieHjvv71cIiwgXG4gICAgXCJ477+9XCIgXG4gIF0gXG5dIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiQ3JlYXRlIGEgYHdpbGRjYXJkYCBBbmFseXplciB3aXRoIGFuIF9uXy1ncmFtIHNpemUgb2YgNCBhbmQgd2l0aG91dCBlbmFibGluZ1xuQW5hbHl6ZXIgZmVhdHVyZXM6XG4iLCJuYW1lIjoiYW5hbHl6ZXJXaWxkY2FyZDEiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, + "analyzerWildcard2_single": { + "request": "LS0tCm5hbWU6IGFuYWx5emVyV2lsZGNhcmQyCmRlc2NyaXB0aW9uOiB8CiAgVXNlIGEgYG5vcm1gIEFuYWx5emVyIGluIGEgYHdpbGRjYXJkYCBBbmFseXplciB0byBub3JtYWxpemUgdGhlIGlucHV0IHRvCiAgbG93ZXJjYXNlIGFuZCBjb252ZXJ0IGFjY2VudGVkIGNoYXJhY3RlcnMgdG8gdGhlaXIgYmFzZSBjaGFyYWN0ZXJzIGJlZm9yZQogIGNyZWF0aW5nIHRyaWdyYW1zIGZyb20gdGhlIHN0cmluZzoKLS0tCnZhciBhbmFseXplcnMgPSByZXF1aXJlKCJAYXJhbmdvZGIvYW5hbHl6ZXJzIik7CnZhciBhbmFseXplcldpbGRjYXJkID0gYW5hbHl6ZXJzLnNhdmUoIndpbGRjYXJkXzMiLCAid2lsZGNhcmQiLCB7IG5ncmFtU2l6ZTogMywgImFuYWx5emVyIjogewogIHR5cGU6ICJub3JtIiwgcHJvcGVydGllczogeyBsb2NhbGU6ICJlbiIsIGFjY2VudDogZmFsc2UsIGNhc2U6ICJsb3dlciIgfQp9IH0sIFsiZnJlcXVlbmN5IiwicG9zaXRpb24iXSk7CgpkYi5fcXVlcnkoYFJFVFVSTiBUT0tFTlMoIlRoZSBxdWljayBicm93biBGb3h4IiwgIndpbGRjYXJkXzMiKWApLnRvQXJyYXkoKTsKfmFuYWx5emVycy5yZW1vdmUoYW5hbHl6ZXJXaWxkY2FyZC5uYW1lKTs=", + "response": "eyJpbnB1dCI6InZhciBhbmFseXplcnMgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FuYWx5emVyc1wiKTtcbnZhciBhbmFseXplcldpbGRjYXJkID0gYW5hbHl6ZXJzLnNhdmUoXCJ3aWxkY2FyZF8zXCIsIFwid2lsZGNhcmRcIiwgeyBuZ3JhbVNpemU6IDMsIFwiYW5hbHl6ZXJcIjoge1xuICB0eXBlOiBcIm5vcm1cIiwgcHJvcGVydGllczogeyBsb2NhbGU6IFwiZW5cIiwgYWNjZW50OiBmYWxzZSwgY2FzZTogXCJsb3dlclwiIH1cbn0gfSwgW1wiZnJlcXVlbmN5XCIsXCJwb3NpdGlvblwiXSk7XG5cbmRiLl9xdWVyeShgUkVUVVJOIFRPS0VOUyhcIlRoZSBxdWljayBicm93biBGb3h4XCIsIFwid2lsZGNhcmRfM1wiKWApLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICBbIFxuICAgIFwi77+9dGhcIiwgXG4gICAgXCJ0aGVcIiwgXG4gICAgXCJoZSBcIiwgXG4gICAgXCJlIHFcIiwgXG4gICAgXCIgcXVcIiwgXG4gICAgXCJxdWlcIiwgXG4gICAgXCJ1aWNcIiwgXG4gICAgXCJpY2tcIiwgXG4gICAgXCJjayBcIiwgXG4gICAgXCJrIGJcIiwgXG4gICAgXCIgYnJcIiwgXG4gICAgXCJicm9cIiwgXG4gICAgXCJyb3dcIiwgXG4gICAgXCJvd25cIiwgXG4gICAgXCJ3biBcIiwgXG4gICAgXCJuIGZcIiwgXG4gICAgXCIgZm9cIiwgXG4gICAgXCJmb3hcIiwgXG4gICAgXCJveHhcIiwgXG4gICAgXCJ4eO+/vVwiLCBcbiAgICBcInjvv71cIiBcbiAgXSBcbl0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiJVc2UgYSBgbm9ybWAgQW5hbHl6ZXIgaW4gYSBgd2lsZGNhcmRgIEFuYWx5emVyIHRvIG5vcm1hbGl6ZSB0aGUgaW5wdXQgdG9cbmxvd2VyY2FzZSBhbmQgY29udmVydCBhY2NlbnRlZCBjaGFyYWN0ZXJzIHRvIHRoZWlyIGJhc2UgY2hhcmFjdGVycyBiZWZvcmVcbmNyZWF0aW5nIHRyaWdyYW1zIGZyb20gdGhlIHN0cmluZzpcbiIsIm5hbWUiOiJhbmFseXplcldpbGRjYXJkMiIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, + "analyzer_wildcard_sample_single": { + "request": "LS0tCm5hbWU6IGFuYWx5emVyX3dpbGRjYXJkX3NhbXBsZQpkZXNjcmlwdGlvbjogfAogIENyZWF0ZSBhIGB3aWxkY2FyZGAgQW5hbHl6ZXIgd2l0aCBhIHNtYWxsIF9uXy1ncmFtIHNpemUsIGZvciBleGFtcGxlLCBpbiBhcmFuZ29zaC4KICBZb3UgY2FuIGxldCB0aGUgQW5hbHl6ZXIgcHJlLXByb2Nlc3MgdGhlIGlucHV0cywgbGlrZSB3aXRoIGEgYG5vcm1gIEFuYWx5emVyIHRvCiAgZW5hYmxlIGNhc2UtaW5zZW5zaXRpdmUgYW5kIGFjY2VudC1pbnNlbnNpdGl2ZSB3aWxkY2FyZCBzZWFyY2guIENyZWF0ZSBhIG1hdGNoaW5nCiAgc3RhbmRhbG9uZSBBbmFseXplciBzbyB0aGF0IHlvdSBjYW4gcHJlLXByb2Nlc3Mgd2lsZGNhcmQgc2VhcmNoIHN0cmluZ3MgaW4gdGhlCiAgc2FtZSBmYXNoaW9uOgotLS0KdmFyIGFuYWx5emVycyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hbmFseXplcnMiKTsKdmFyIHdpbGRjYXJkTm9ybUFuYWx5emVyID0gYW5hbHl6ZXJzLnNhdmUoIndpbGRjYXJkX25vcm0iLCAid2lsZGNhcmQiLCB7IG5ncmFtU2l6ZTogMywgYW5hbHl6ZXI6IHsgdHlwZTogIm5vcm0iLCBwcm9wZXJ0aWVzOiB7IGxvY2FsZTogImVuIiwgYWNjZW50OiBmYWxzZSwgY2FzZTogImxvd2VyIiB9IH0gfSwgWyJmcmVxdWVuY3kiLCAibm9ybSJdKTsKdmFyIG1hdGNoaW5nTm9ybUFuYWx5emVyID0gYW5hbHl6ZXJzLnNhdmUoIm9ubHlfbm9ybSIsICJub3JtIiwgeyBsb2NhbGU6ICJlbiIsIGFjY2VudDogZmFsc2UsIGNhc2U6ICJsb3dlciIgfSk7Cn5hbmFseXplcnMucmVtb3ZlKCJ3aWxkY2FyZF9ub3JtIik7Cn5hbmFseXplcnMucmVtb3ZlKCJvbmx5X25vcm0iKTs=", + "response": "eyJpbnB1dCI6InZhciBhbmFseXplcnMgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FuYWx5emVyc1wiKTtcbnZhciB3aWxkY2FyZE5vcm1BbmFseXplciA9IGFuYWx5emVycy5zYXZlKFwid2lsZGNhcmRfbm9ybVwiLCBcIndpbGRjYXJkXCIsIHsgbmdyYW1TaXplOiAzLCBhbmFseXplcjogeyB0eXBlOiBcIm5vcm1cIiwgcHJvcGVydGllczogeyBsb2NhbGU6IFwiZW5cIiwgYWNjZW50OiBmYWxzZSwgY2FzZTogXCJsb3dlclwiIH0gfSB9LCBbXCJmcmVxdWVuY3lcIiwgXCJub3JtXCJdKTtcbnZhciBtYXRjaGluZ05vcm1BbmFseXplciA9IGFuYWx5emVycy5zYXZlKFwib25seV9ub3JtXCIsIFwibm9ybVwiLCB7IGxvY2FsZTogXCJlblwiLCBhY2NlbnQ6IGZhbHNlLCBjYXNlOiBcImxvd2VyXCIgfSk7Iiwib3V0cHV0IjoiRW1wdHkgT3V0cHV0IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiQ3JlYXRlIGEgYHdpbGRjYXJkYCBBbmFseXplciB3aXRoIGEgc21hbGwgX25fLWdyYW0gc2l6ZSwgZm9yIGV4YW1wbGUsIGluIGFyYW5nb3NoLlxuWW91IGNhbiBsZXQgdGhlIEFuYWx5emVyIHByZS1wcm9jZXNzIHRoZSBpbnB1dHMsIGxpa2Ugd2l0aCBhIGBub3JtYCBBbmFseXplciB0b1xuZW5hYmxlIGNhc2UtaW5zZW5zaXRpdmUgYW5kIGFjY2VudC1pbnNlbnNpdGl2ZSB3aWxkY2FyZCBzZWFyY2guIENyZWF0ZSBhIG1hdGNoaW5nXG5zdGFuZGFsb25lIEFuYWx5emVyIHNvIHRoYXQgeW91IGNhbiBwcmUtcHJvY2VzcyB3aWxkY2FyZCBzZWFyY2ggc3RyaW5ncyBpbiB0aGVcbnNhbWUgZmFzaGlvbjpcbiIsIm5hbWUiOiJhbmFseXplcl93aWxkY2FyZF9zYW1wbGUiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, "aqlArrayAppend_1_single": { "request": "LS0tCm5hbWU6IGFxbEFycmF5QXBwZW5kXzEKZGVzY3JpcHRpb246ICcnCi0tLQpSRVRVUk4gQVBQRU5EKFsgMSwgMiwgMyBdLCBbIDUsIDYsIDkgXSk=", "response": "eyJpbnB1dCI6IlJFVFVSTiBBUFBFTkQoWyAxLCAyLCAzIF0sIFsgNSwgNiwgOSBdKSIsIm91dHB1dCI6IltvYmplY3QgQXJhbmdvUXVlcnlDdXJzb3IsIGNvdW50OiAxLCBjYWNoZWQ6IGZhbHNlLCBoYXNNb3JlOiBmYWxzZV1cblxuWyBcbiAgWyBcbiAgICAxLCBcbiAgICAyLCBcbiAgICAzLCBcbiAgICA1LCBcbiAgICA2LCBcbiAgICA5IFxuICBdIFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJhcWxBcnJheUFwcGVuZF8xIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" From ebc93fa42420808b68f83fdb4d2cfa1f0834b784 Mon Sep 17 00:00:00 2001 From: Simran Spiller Date: Tue, 6 Feb 2024 19:09:40 +0100 Subject: [PATCH 11/11] Add line breaks to code to avoid the content getting cut off without Show more button --- .../working-with-indexes/inverted-indexes.md | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md b/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md index 4e26201422..236e0c2e72 100644 --- a/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md +++ b/site/content/3.12/index-and-search/indexing/working-with-indexes/inverted-indexes.md @@ -470,10 +470,18 @@ operator to perform a wildcard search: ```js var analyzers = require("@arangodb/analyzers"); -var wildcardNormAnalyzer = analyzers.save("wildcard_norm", "wildcard", { ngramSize: 3, analyzer: { type: "norm", properties: { locale: "en", accent: false, case: "lower" } } }, ["frequency", "norm"]); -var matchingNormAnalyzer = analyzers.save("only_norm", "norm", { locale: "en", accent: false, case: "lower" }); -db.imdb_vertices.ensureIndex({ name: "inv-wildcard", type: "inverted", fields: [ { name: "description", analyzer: "wildcard_norm" } ] }); +var wildcardNormAnalyzer = analyzers.save("wildcard_norm", "wildcard", { + ngramSize: 3, analyzer: { + type: "norm", properties: { locale: "en", accent: false, case: "lower" } + } }, ["frequency", "norm"]); + +var matchingNormAnalyzer = analyzers.save("only_norm", "norm", { + locale: "en", accent: false, case: "lower" }); + +db.imdb_vertices.ensureIndex({ name: "inv-wildcard", type: "inverted", fields: [ + { name: "description", analyzer: "wildcard_norm" } +] }); db._query(` LET search = "%AY!"