diff --git a/docs/docs/integrations/chat/kinetica.ipynb b/docs/docs/integrations/chat/kinetica.ipynb new file mode 100644 index 0000000000..cacff2ee2e --- /dev/null +++ b/docs/docs/integrations/chat/kinetica.ipynb @@ -0,0 +1,654 @@ +{ + "cells": [ + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "---\n", + "sidebar_label: Kinetica\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kinetica SqlAssist LLM Demo\n", + "\n", + "This notebook demonstrates how to use Kinetica to transform natural language into SQL\n", + "and simplify the process of data retrieval. This demo is intended to show the mechanics\n", + "of creating and using a chain as opposed to the capabilities of the LLM.\n", + "\n", + "## Overview\n", + "\n", + "With the Kinetica LLM workflow you create an LLM context in the database that provides\n", + "information needed for infefencing that includes tables, annotations, rules, and\n", + "samples. Invoking ``ChatKinetica.load_messages_from_context()`` will retrieve the\n", + "context information from the database so that it can be used to create a chat prompt.\n", + "\n", + "The chat prompt consists of a ``SystemMessage`` and pairs of\n", + "``HumanMessage``/``AIMessage`` that contain the samples which are question/SQL\n", + "pairs. You can append pairs samples to this list but it is not intended to\n", + "facilitate a typical natural language conversation.\n", + "\n", + "When you create a chain from the chat prompt and execute it, the Kinetica LLM will\n", + "generate SQL from the input. Optionally you can use ``KineticaSqlOutputParser`` to\n", + "execute the SQL and return the result as a dataframe.\n", + "\n", + "Currently, 2 LLM's are supported for SQL generation: \n", + "\n", + "1. **Kinetica SQL-GPT**: This LLM is based on OpenAI ChatGPT API.\n", + "2. **Kinetica SqlAssist**: This LLM is purpose built to integrate with the Kinetica\n", + " database and it can run in a secure customer premise.\n", + "\n", + "For this demo we will be using **SqlAssist**. See the [Kinetica Documentation\n", + "site](https://docs.kinetica.com/7.1/sql-gpt/concepts/) for more information.\n", + "\n", + "## Prerequisites\n", + "\n", + "To get started you will need a Kinetica DB instance. If you don't have one you can\n", + "obtain a [free development instance](https://cloud.kinetica.com/trynow).\n", + "\n", + "You will need to install the following packages..." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# Install Langchain community and core packages\n", + "%pip install --upgrade --quiet langchain-core langchain-community\n", + "\n", + "# Install Kineitca DB connection package\n", + "%pip install --upgrade --quiet gpudb typeguard\n", + "\n", + "# Install packages needed for this tutorial\n", + "%pip install --upgrade --quiet faker" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Database Connection\n", + "\n", + "You must set the database connection in the following environment variables. If you are using a virtual environment you can set them in the `.env` file of the project:\n", + "* `KINETICA_URL`: Database connection URL\n", + "* `KINETICA_USER`: Database user\n", + "* `KINETICA_PASSWD`: Secure password.\n", + "\n", + "If you can create an instance of `KineticaChatLLM` then you are successfully connected." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from langchain_community.chat_models.kinetica import ChatKinetica\n", + "\n", + "kinetica_llm = ChatKinetica()\n", + "\n", + "# Test table we will create\n", + "table_name = \"demo.user_profiles\"\n", + "\n", + "# LLM Context we will create\n", + "kinetica_ctx = \"demo.test_llm_ctx\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create test data\n", + "\n", + "Before we can generate SQL we will need to create a Kinetica table and an LLM context that can inference the table.\n", + "\n", + "### Create some fake user profiles\n", + "\n", + "We will use the `faker` package to create a dataframe with 100 fake profiles." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
usernamenamesexaddressmailbirthdate
id
0eduardo69Haley BeckF59836 Carla Causeway Suite 939\\nPort Eugene, I...meltondenise@yahoo.com1997-09-09
1lbarreraJoshua StephensM3108 Christina Forges\\nPort Timothychester, KY...erica80@hotmail.com1924-05-05
2bburtonPaula KaiserFUnit 7405 Box 3052\\nDPO AE 09858timothypotts@gmail.com1933-09-06
3melissa49Wendy ReeseF6408 Christopher Hill Apt. 459\\nNew Benjamin, ...dadams@gmail.com1988-07-28
4melissacarterManuel RiosM2241 Bell Gardens Suite 723\\nScottside, CA 38463williamayala@gmail.com1930-12-19
\n", + "
" + ], + "text/plain": [ + " username name sex \\\n", + "id \n", + "0 eduardo69 Haley Beck F \n", + "1 lbarrera Joshua Stephens M \n", + "2 bburton Paula Kaiser F \n", + "3 melissa49 Wendy Reese F \n", + "4 melissacarter Manuel Rios M \n", + "\n", + " address mail \\\n", + "id \n", + "0 59836 Carla Causeway Suite 939\\nPort Eugene, I... meltondenise@yahoo.com \n", + "1 3108 Christina Forges\\nPort Timothychester, KY... erica80@hotmail.com \n", + "2 Unit 7405 Box 3052\\nDPO AE 09858 timothypotts@gmail.com \n", + "3 6408 Christopher Hill Apt. 459\\nNew Benjamin, ... dadams@gmail.com \n", + "4 2241 Bell Gardens Suite 723\\nScottside, CA 38463 williamayala@gmail.com \n", + "\n", + " birthdate \n", + "id \n", + "0 1997-09-09 \n", + "1 1924-05-05 \n", + "2 1933-09-06 \n", + "3 1988-07-28 \n", + "4 1930-12-19 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from typing import Generator\n", + "\n", + "import pandas as pd\n", + "from faker import Faker\n", + "\n", + "Faker.seed(5467)\n", + "faker = Faker(locale=\"en-US\")\n", + "\n", + "\n", + "def profile_gen(count: int) -> Generator:\n", + " for id in range(0, count):\n", + " rec = dict(id=id, **faker.simple_profile())\n", + " rec[\"birthdate\"] = pd.Timestamp(rec[\"birthdate\"])\n", + " yield rec\n", + "\n", + "\n", + "load_df = pd.DataFrame.from_records(data=profile_gen(100), index=\"id\")\n", + "load_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a Kinetica table from the Dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nametypeproperties
0usernamestring[char32]
1namestring[char32]
2sexstring[char1]
3addressstring[char64]
4mailstring[char32]
5birthdatelong[timestamp]
\n", + "
" + ], + "text/plain": [ + " name type properties\n", + "0 username string [char32]\n", + "1 name string [char32]\n", + "2 sex string [char1]\n", + "3 address string [char64]\n", + "4 mail string [char32]\n", + "5 birthdate long [timestamp]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gpudb import GPUdbTable\n", + "\n", + "gpudb_table = GPUdbTable.from_df(\n", + " load_df,\n", + " db=kinetica_llm.kdbc,\n", + " table_name=table_name,\n", + " clear_table=True,\n", + " load_data=True,\n", + ")\n", + "\n", + "# See the Kinetica column types\n", + "gpudb_table.type_as_df()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the LLM context\n", + "\n", + "You can create an LLM Context using the Kinetica Workbench UI or you can manually create it with the `CREATE OR REPLACE CONTEXT` syntax. \n", + "\n", + "Here we create a context from the SQL syntax referencing the table we created." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'OK',\n", + " 'message': '',\n", + " 'data_type': 'execute_sql_response',\n", + " 'response_time': 0.0148}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create an LLM context for the table.\n", + "\n", + "from gpudb import GPUdbException\n", + "\n", + "sql = f\"\"\"\n", + "CREATE OR REPLACE CONTEXT {kinetica_ctx}\n", + "(\n", + " TABLE = demo.test_profiles\n", + " COMMENT = 'Contains user profiles.'\n", + "),\n", + "(\n", + " SAMPLES = (\n", + " 'How many male users are there?' = \n", + " 'select count(1) as num_users\n", + " from demo.test_profiles\n", + " where sex = ''M'';')\n", + ")\n", + "\"\"\"\n", + "\n", + "\n", + "def _check_error(response: dict) -> None:\n", + " status = response[\"status_info\"][\"status\"]\n", + " if status != \"OK\":\n", + " message = response[\"status_info\"][\"message\"]\n", + " raise GPUdbException(\"[%s]: %s\" % (status, message))\n", + "\n", + "\n", + "response = kinetica_llm.kdbc.execute_sql(sql)\n", + "_check_error(response)\n", + "response[\"status_info\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use Langchain for inferencing\n", + "\n", + "In the example below we will create a chain from the previously created table and LLM context. This chain will generate SQL and return the resulting data as a dataframe.\n", + "\n", + "### Load the chat prompt from the Kinetica DB\n", + "\n", + "The `load_messages_from_context()` function will retrieve a context from the DB and convert it into a list of chat messages that we use to create a ``ChatPromptTemplate``." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================\u001b[1m System Message \u001b[0m================================\n", + "\n", + "CREATE TABLE demo.test_profiles AS\n", + "(\n", + " username VARCHAR (32) NOT NULL,\n", + " name VARCHAR (32) NOT NULL,\n", + " sex VARCHAR (1) NOT NULL,\n", + " address VARCHAR (64) NOT NULL,\n", + " mail VARCHAR (32) NOT NULL,\n", + " birthdate TIMESTAMP NOT NULL\n", + ");\n", + "COMMENT ON TABLE demo.test_profiles IS 'Contains user profiles.';\n", + "\n", + "================================\u001b[1m Human Message \u001b[0m=================================\n", + "\n", + "How many male users are there?\n", + "\n", + "==================================\u001b[1m Ai Message \u001b[0m==================================\n", + "\n", + "select count(1) as num_users\n", + " from demo.test_profiles\n", + " where sex = 'M';\n", + "\n", + "================================\u001b[1m Human Message \u001b[0m=================================\n", + "\n", + "\u001b[33;1m\u001b[1;3m{input}\u001b[0m\n" + ] + } + ], + "source": [ + "from langchain_core.prompts import ChatPromptTemplate\n", + "\n", + "# load the context from the database\n", + "ctx_messages = kinetica_llm.load_messages_from_context(kinetica_ctx)\n", + "\n", + "# Add the input prompt. This is where input question will be substituted.\n", + "ctx_messages.append((\"human\", \"{input}\"))\n", + "\n", + "# Create the prompt template.\n", + "prompt_template = ChatPromptTemplate.from_messages(ctx_messages)\n", + "prompt_template.pretty_print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the chain\n", + "\n", + "The last element of this chain is `KineticaSqlOutputParser` that will execute the SQL and return a dataframe. This is optional and if we left it out then only SQL would be returned." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from langchain_community.chat_models.kinetica import (\n", + " KineticaSqlOutputParser,\n", + " KineticaSqlResponse,\n", + ")\n", + "\n", + "chain = prompt_template | kinetica_llm | KineticaSqlOutputParser(kdbc=kinetica_llm.kdbc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the SQL\n", + "\n", + "The chain we created will take a question as input and return a ``KineticaSqlResponse`` containing the generated SQL and data. The question must be relevant to the to LLM context we used to create the prompt." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SQL: SELECT username, name\n", + " FROM demo.test_profiles\n", + " WHERE sex = 'F'\n", + " ORDER BY username;\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
usernamename
0alexander40Tina Ramirez
1bburtonPaula Kaiser
2brian12Stefanie Williams
3brownannaJennifer Rowe
4carl19Amanda Potts
\n", + "
" + ], + "text/plain": [ + " username name\n", + "0 alexander40 Tina Ramirez\n", + "1 bburton Paula Kaiser\n", + "2 brian12 Stefanie Williams\n", + "3 brownanna Jennifer Rowe\n", + "4 carl19 Amanda Potts" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Here you must ask a question relevant to the LLM context provided in the prompt template.\n", + "response: KineticaSqlResponse = chain.invoke(\n", + " {\"input\": \"What are the female users ordered by username?\"}\n", + ")\n", + "\n", + "print(f\"SQL: {response.sql}\")\n", + "response.dataframe.head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "langchain", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/docs/integrations/providers/kinetica.mdx b/docs/docs/integrations/providers/kinetica.mdx new file mode 100644 index 0000000000..317bdbf454 --- /dev/null +++ b/docs/docs/integrations/providers/kinetica.mdx @@ -0,0 +1,28 @@ +# Kinetica + +[Kinetica](https://www.kinetica.com/) is a real-time database purpose built for enabling +analytics and generative AI on time-series & spatial data. + +## Chat Model + +The Kinetica LLM wrapper uses the [Kinetica SqlAssist +LLM](https://docs.kinetica.com/7.2/sql-gpt/concepts/) to transform natural language into +SQL to simplify the process of data retrieval. + +See [Kinetica SqlAssist LLM Demo](/docs/integrations/chat/kinetica) for usage. + +```python +from langchain_community.chat_models.kinetica import ChatKinetica +``` + +## Vector Store + +The Kinetca vectorstore wrapper leverages Kinetica's native support for [vector +similarity search](https://docs.kinetica.com/7.2/vector_search/). + +See [Kinetica Vectorsore API](/docs/integrations/vectorstores/kinetica) for usage. + +```python +from langchain_community.vectorstores import Kinetica +``` + diff --git a/libs/community/Makefile b/libs/community/Makefile index acec04864a..e7b1b6465a 100644 --- a/libs/community/Makefile +++ b/libs/community/Makefile @@ -36,7 +36,7 @@ extended_tests: PYTHON_FILES=. MYPY_CACHE=.mypy_cache lint format: PYTHON_FILES=. -lint_diff format_diff: PYTHON_FILES=$(shell git diff --relative=libs/community -name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$') +lint_diff format_diff: PYTHON_FILES=$(shell git diff --relative=libs/community --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$') lint_package: PYTHON_FILES=langchain_community lint_tests: PYTHON_FILES=tests lint_tests: MYPY_CACHE=.mypy_cache_test diff --git a/libs/community/langchain_community/chat_models/__init__.py b/libs/community/langchain_community/chat_models/__init__.py index 8a8fd1fd78..00f7ffeb40 100644 --- a/libs/community/langchain_community/chat_models/__init__.py +++ b/libs/community/langchain_community/chat_models/__init__.py @@ -38,6 +38,7 @@ from langchain_community.chat_models.human import HumanInputChatModel from langchain_community.chat_models.hunyuan import ChatHunyuan from langchain_community.chat_models.javelin_ai_gateway import ChatJavelinAIGateway from langchain_community.chat_models.jinachat import JinaChat +from langchain_community.chat_models.kinetica import ChatKinetica from langchain_community.chat_models.konko import ChatKonko from langchain_community.chat_models.litellm import ChatLiteLLM from langchain_community.chat_models.litellm_router import ChatLiteLLMRouter @@ -97,4 +98,5 @@ __all__ = [ "GPTRouter", "ChatYuan2", "ChatZhipuAI", + "ChatKinetica", ] diff --git a/libs/community/langchain_community/chat_models/kinetica.py b/libs/community/langchain_community/chat_models/kinetica.py new file mode 100644 index 0000000000..38c5809aca --- /dev/null +++ b/libs/community/langchain_community/chat_models/kinetica.py @@ -0,0 +1,601 @@ +## +# Copyright (c) 2024, Chad Juliano, Kinetica DB Inc. +## +"""Kinetica SQL generation LLM API.""" + +import json +import logging +import os +import re +from importlib.metadata import version +from pathlib import Path +from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast + +if TYPE_CHECKING: + import gpudb + +from langchain_core.callbacks import CallbackManagerForLLMRun +from langchain_core.language_models.chat_models import BaseChatModel +from langchain_core.messages import ( + AIMessage, + BaseMessage, + HumanMessage, + SystemMessage, +) +from langchain_core.output_parsers.transform import BaseOutputParser +from langchain_core.outputs import ChatGeneration, ChatResult, Generation +from langchain_core.pydantic_v1 import BaseModel, Field, root_validator + +LOG = logging.getLogger(__name__) + +# Kinetica pydantic API datatypes + + +class _KdtSuggestContext(BaseModel): + """pydantic API request type""" + + table: Optional[str] = Field(default=None, title="Name of table") + description: Optional[str] = Field(default=None, title="Table description") + columns: List[str] = Field(default=None, title="Table columns list") + rules: Optional[List[str]] = Field( + default=None, title="Rules that apply to the table." + ) + samples: Optional[Dict] = Field( + default=None, title="Samples that apply to the entire context." + ) + + def to_system_str(self) -> str: + lines = [] + lines.append(f"CREATE TABLE {self.table} AS") + lines.append("(") + + if not self.columns or len(self.columns) == 0: + ValueError(detail="columns list can't be null.") # type: ignore + + columns = [] + for column in self.columns: + column = column.replace('"', "").strip() + columns.append(f" {column}") + lines.append(",\n".join(columns)) + lines.append(");") + + if self.description: + lines.append(f"COMMENT ON TABLE {self.table} IS '{self.description}';") + + if self.rules and len(self.rules) > 0: + lines.append( + f"-- When querying table {self.table} the following rules apply:" + ) + for rule in self.rules: + lines.append(f"-- * {rule}") + + result = "\n".join(lines) + return result + + +class _KdtSuggestPayload(BaseModel): + """pydantic API request type""" + + question: Optional[str] + context: List[_KdtSuggestContext] + + def get_system_str(self) -> str: + lines = [] + for table_context in self.context: + if table_context.table is None: + continue + context_str = table_context.to_system_str() + lines.append(context_str) + return "\n\n".join(lines) + + def get_messages(self) -> List[Dict]: + messages = [] + for context in self.context: + if context.samples is None: + continue + for question, answer in context.samples.items(): + # unescape double quotes + answer = answer.replace("''", "'") + + messages.append(dict(role="user", content=question or "")) + messages.append(dict(role="assistant", content=answer)) + return messages + + def to_completion(self) -> Dict: + messages = [] + messages.append(dict(role="system", content=self.get_system_str())) + messages.extend(self.get_messages()) + messages.append(dict(role="user", content=self.question or "")) + response = dict(messages=messages) + return response + + +class _KdtoSuggestRequest(BaseModel): + """pydantic API request type""" + + payload: _KdtSuggestPayload + + +class _KdtMessage(BaseModel): + """pydantic API response type""" + + role: str = Field(default=None, title="One of [user|assistant|system]") + content: str + + +class _KdtChoice(BaseModel): + """pydantic API response type""" + + index: int + message: _KdtMessage = Field(default=None, title="The generated SQL") + finish_reason: str + + +class _KdtUsage(BaseModel): + """pydantic API response type""" + + prompt_tokens: int + completion_tokens: int + total_tokens: int + + +class _KdtSqlResponse(BaseModel): + """pydantic API response type""" + + id: str + object: str + created: int + model: str + choices: List[_KdtChoice] + usage: _KdtUsage + prompt: str = Field(default=None, title="The input question") + + +class _KdtCompletionResponse(BaseModel): + """pydantic API response type""" + + status: str + data: _KdtSqlResponse + + +class _KineticaLlmFileContextParser: + """Parser for Kinetica LLM context datafiles.""" + + # parse line into a dict containing role and content + PARSER = re.compile(r"^<\|(?P\w+)\|>\W*(?P.*)$", re.DOTALL) + + @classmethod + def _removesuffix(cls, text: str, suffix: str) -> str: + if suffix and text.endswith(suffix): + return text[: -len(suffix)] + return text + + @classmethod + def parse_dialogue_file(cls, input_file: os.PathLike) -> Dict: + path = Path(input_file) + # schema = path.name.removesuffix(".txt") python 3.9 + schema = cls._removesuffix(path.name, ".txt") + + lines = open(input_file).read() + return cls.parse_dialogue(lines, schema) + + @classmethod + def parse_dialogue(cls, text: str, schema: str) -> Dict: + messages = [] + system = None + + lines = text.split("<|end|>") + user_message = None + + for idx, line in enumerate(lines): + line = line.strip() + + if len(line) == 0: + continue + + match = cls.PARSER.match(line) + if match is None: + raise ValueError(f"Could not find starting token in: {line}") + + groupdict = match.groupdict() + role = groupdict["role"] + + if role == "system": + if system is not None: + raise ValueError(f"Only one system token allowed in: {line}") + system = groupdict["content"] + elif role == "user": + if user_message is not None: + raise ValueError( + f"Found user token without assistant token: {line}" + ) + user_message = groupdict + elif role == "assistant": + if user_message is None: + raise Exception(f"Found assistant token without user token: {line}") + messages.append(user_message) + messages.append(groupdict) + user_message = None + else: + raise ValueError(f"Unknown token: {role}") + + return {"schema": schema, "system": system, "messages": messages} + + +class KineticaUtil: + """Kinetica utility functions.""" + + @classmethod + def create_kdbc( + cls, + url: Optional[str] = None, + user: Optional[str] = None, + passwd: Optional[str] = None, + ) -> "gpudb.GPUdb": + """Create a connectica connection object and verify connectivity. + + If None is passed for one or more of the parameters then an attempt will be made + to retrieve the value from the related environment variable. + + Args: + url: The Kinetica URL or ``KINETICA_URL`` if None. + user: The Kinetica user or ``KINETICA_USER`` if None. + passwd: The Kinetica password or ``KINETICA_PASSWD`` if None. + + Returns: + The Kinetica connection object. + """ + + try: + import gpudb + except ModuleNotFoundError: + raise ImportError( + "Could not import Kinetica python package. " + "Please install it with `pip install gpudb`." + ) + + url = cls._get_env("KINETICA_URL", url) + user = cls._get_env("KINETICA_USER", user) + passwd = cls._get_env("KINETICA_PASSWD", passwd) + + options = gpudb.GPUdb.Options() + options.username = user + options.password = passwd + options.skip_ssl_cert_verification = True + options.disable_failover = True + options.logging_level = "INFO" + kdbc = gpudb.GPUdb(host=url, options=options) + + LOG.info( + "Connected to Kinetica: {}. (api={}, server={})".format( + kdbc.get_url(), version("gpudb"), kdbc.server_version + ) + ) + + return kdbc + + @classmethod + def _get_env(cls, name: str, default: Optional[str]) -> str: + """Get an environment variable or use a default.""" + if default is not None: + return default + + result = os.getenv(name) + if result is not None: + return result + + raise ValueError( + f"Parameter was not passed and not found in the environment: {name}" + ) + + +class ChatKinetica(BaseChatModel): + """Kinetica LLM Chat Model API. + + Prerequisites for using this API: + + * The ``gpudb`` and ``typeguard`` packages installed. + * A Kinetica DB instance. + * Kinetica host specified in ``KINETICA_URL`` + * Kinetica login specified ``KINETICA_USER``, and ``KINETICA_PASSWD``. + * An LLM context that specifies the tables and samples to use for inferencing. + + This API is intended to interact with the Kinetica SqlAssist LLM that supports + generation of SQL from natural language. + + In the Kinetica LLM workflow you create an LLM context in the database that provides + information needed for infefencing that includes tables, annotations, rules, and + samples. Invoking ``load_messages_from_context()`` will retrieve the contxt + information from the database so that it can be used to create a chat prompt. + + The chat prompt consists of a ``SystemMessage`` and pairs of + ``HumanMessage``/``AIMessage`` that contain the samples which are question/SQL + pairs. You can append pairs samples to this list but it is not intended to + facilitate a typical natural language conversation. + + When you create a chain from the chat prompt and execute it, the Kinetica LLM will + generate SQL from the input. Optionally you can use ``KineticaSqlOutputParser`` to + execute the SQL and return the result as a dataframe. + + The following example creates an LLM using the environment variables for the + Kinetica connection. This will fail if the API is unable to connect to the database. + + Example: + .. code-block:: python + + from langchain_community.chat_models.kinetica import KineticaChatLLM + kinetica_llm = KineticaChatLLM() + + If you prefer to pass connection information directly then you can create a + connection using ``KineticaUtil.create_kdbc()``. + + Example: + .. code-block:: python + + from langchain_community.chat_models.kinetica import ( + KineticaChatLLM, KineticaUtil) + kdbc = KineticaUtil._create_kdbc(url=url, user=user, passwd=passwd) + kinetica_llm = KineticaChatLLM(kdbc=kdbc) + """ + + kdbc: Any = Field(exclude=True) + """ Kinetica DB connection. """ + + @root_validator() + def validate_environment(cls, values: Dict) -> Dict: + """Pydantic object validator.""" + + kdbc = values.get("kdbc", None) + if kdbc is None: + kdbc = KineticaUtil.create_kdbc() + values["kdbc"] = kdbc + return values + + @property + def _llm_type(self) -> str: + return "kinetica-sqlassist" + + @property + def _identifying_params(self) -> Dict[str, Any]: + return dict( + kinetica_version=str(self.kdbc.server_version), api_version=version("gpudb") + ) + + def _generate( + self, + messages: List[BaseMessage], + stop: Optional[List[str]] = None, + run_manager: Optional[CallbackManagerForLLMRun] = None, + **kwargs: Any, + ) -> ChatResult: + if stop is not None: + raise ValueError("stop kwargs are not permitted.") + + dict_messages = [self._convert_message_to_dict(m) for m in messages] + sql_response = self._submit_completion(dict_messages) + + response_message = sql_response.choices[0].message + # generated_dict = response_message.model_dump() # pydantic v2 + generated_dict = response_message.dict() + + generated_message = self._convert_message_from_dict(generated_dict) + + llm_output = dict( + input_tokens=sql_response.usage.prompt_tokens, + output_tokens=sql_response.usage.completion_tokens, + model_name=sql_response.model, + ) + return ChatResult( + generations=[ChatGeneration(message=generated_message)], + llm_output=llm_output, + ) + + def load_messages_from_context(self, context_name: str) -> List: + """Load a lanchain prompt from a Kinetica context. + + A Kinetica Context is an object created with the Kinetica Workbench UI or with + SQL syntax. This function will convert the data in the context to a list of + messages that can be used as a prompt. The messages will contain a + ``SystemMessage`` followed by pairs of ``HumanMessage``/``AIMessage`` that + contain the samples. + + Args: + context_name: The name of an LLM context in the database. + + Returns: + A list of messages containing the information from the context. + """ + + # query kinetica for the prompt + sql = f"GENERATE PROMPT WITH OPTIONS (CONTEXT_NAMES = '{context_name}')" + result = self._execute_sql(sql) + prompt = result["Prompt"] + prompt_json = json.loads(prompt) + + # convert the prompt to messages + # request = SuggestRequest.model_validate(prompt_json) # pydantic v2 + request = _KdtoSuggestRequest.parse_obj(prompt_json) + payload = request.payload + + dict_messages = [] + dict_messages.append(dict(role="system", content=payload.get_system_str())) + dict_messages.extend(payload.get_messages()) + messages = [self._convert_message_from_dict(m) for m in dict_messages] + return messages + + def _submit_completion(self, messages: List[Dict]) -> _KdtSqlResponse: + """Submit a /chat/completions request to Kinetica.""" + + request = dict(messages=messages) + request_json = json.dumps(request) + response_raw = self.kdbc._GPUdb__submit_request_json( + "/chat/completions", request_json + ) + response_json = json.loads(response_raw) + + status = response_json["status"] + if status != "OK": + message = response_json["message"] + match_resp = re.compile(r"response:({.*})") + result = match_resp.search(message) + if result is not None: + response = result.group(1) + response_json = json.loads(response) + message = response_json["message"] + raise ValueError(message) + + data = response_json["data"] + # response = CompletionResponse.model_validate(data) # pydantic v2 + response = _KdtCompletionResponse.parse_obj(data) + if response.status != "OK": + raise ValueError("SQL Generation failed") + return response.data + + def _execute_sql(self, sql: str) -> Dict: + """Execute an SQL query and return the result.""" + + response = self.kdbc.execute_sql_and_decode( + sql, limit=1, get_column_major=False + ) + + status_info = response["status_info"] + if status_info["status"] != "OK": + message = status_info["message"] + raise ValueError(message) + + records = response["records"] + if len(records) != 1: + raise ValueError("No records returned.") + + record = records[0] + response_dict = {} + for col, val in record.items(): + response_dict[col] = val + return response_dict + + @classmethod + def load_messages_from_datafile(cls, sa_datafile: Path) -> List[BaseMessage]: + """Load a lanchain prompt from a Kinetica context datafile.""" + datafile_dict = _KineticaLlmFileContextParser.parse_dialogue_file(sa_datafile) + messages = cls._convert_dict_to_messages(datafile_dict) + return messages + + @classmethod + def _convert_message_to_dict(cls, message: BaseMessage) -> Dict: + """Convert a single message to a BaseMessage.""" + + content = cast(str, message.content) + if isinstance(message, HumanMessage): + role = "user" + elif isinstance(message, AIMessage): + role = "assistant" + elif isinstance(message, SystemMessage): + role = "system" + else: + raise ValueError(f"Got unsupported message type: {message}") + + result_message = dict(role=role, content=content) + return result_message + + @classmethod + def _convert_message_from_dict(cls, message: Dict) -> BaseMessage: + """Convert a single message from a BaseMessage.""" + + role = message["role"] + content = message["content"] + if role == "user": + return HumanMessage(content=content) + elif role == "assistant": + return AIMessage(content=content) + elif role == "system": + return SystemMessage(content=content) + else: + raise ValueError(f"Got unsupported role: {role}") + + @classmethod + def _convert_dict_to_messages(cls, sa_data: Dict) -> List[BaseMessage]: + """Convert a dict to a list of BaseMessages.""" + + schema = sa_data["schema"] + system = sa_data["system"] + messages = sa_data["messages"] + LOG.info(f"Importing prompt for schema: {schema}") + + result_list: List[BaseMessage] = [] + result_list.append(SystemMessage(content=system)) + result_list.extend([cls._convert_message_from_dict(m) for m in messages]) + return result_list + + +class KineticaSqlResponse(BaseModel): + """Response containing SQL and the fetched data. + + This object is returned by a chain with ``KineticaSqlOutputParser`` and it contains + the generated SQL and related Pandas Dataframe fetched from the database. + """ + + sql: str = Field(default=None) + """The generated SQL.""" + + # dataframe: "pd.DataFrame" = Field(default=None) + dataframe: Any = Field(default=None) + """The Pandas dataframe containing the fetched data.""" + + class Config: + """Configuration for this pydantic object.""" + + arbitrary_types_allowed = True + + +class KineticaSqlOutputParser(BaseOutputParser[KineticaSqlResponse]): + """Fetch and return data from the Kinetica LLM. + + This object is used as the last element of a chain to execute generated SQL and it + will output a ``KineticaSqlResponse`` containing the SQL and a pandas dataframe with + the fetched data. + + Example: + .. code-block:: python + + from langchain_community.chat_models.kinetica import ( + KineticaChatLLM, KineticaSqlOutputParser) + kinetica_llm = KineticaChatLLM() + + # create chain + ctx_messages = kinetica_llm.load_messages_from_context(self.context_name) + ctx_messages.append(("human", "{input}")) + prompt_template = ChatPromptTemplate.from_messages(ctx_messages) + chain = ( + prompt_template + | kinetica_llm + | KineticaSqlOutputParser(kdbc=kinetica_llm.kdbc) + ) + sql_response: KineticaSqlResponse = chain.invoke( + {"input": "What are the female users ordered by username?"} + ) + + assert isinstance(sql_response, KineticaSqlResponse) + LOG.info(f"SQL Response: {sql_response.sql}") + assert isinstance(sql_response.dataframe, pd.DataFrame) + """ + + kdbc: Any = Field(exclude=True) + """ Kinetica DB connection. """ + + class Config: + """Configuration for this pydantic object.""" + + arbitrary_types_allowed = True + + def parse(self, text: str) -> KineticaSqlResponse: + df = self.kdbc.to_df(text) + return KineticaSqlResponse(sql=text, dataframe=df) + + def parse_result( + self, result: List[Generation], *, partial: bool = False + ) -> KineticaSqlResponse: + return self.parse(result[0].text) + + @property + def _type(self) -> str: + return "kinetica_sql_output_parser" diff --git a/libs/community/tests/integration_tests/.env.example b/libs/community/tests/integration_tests/.env.example index 99be838353..2a6c04c53e 100644 --- a/libs/community/tests/integration_tests/.env.example +++ b/libs/community/tests/integration_tests/.env.example @@ -50,3 +50,9 @@ POWERBI_NUMROWS=_num_rows_in_your_test_table # MongoDB Atlas Vector Search MONGODB_ATLAS_URI=your_mongodb_atlas_connection_string + + +# Kinetica +KINETICA_URL = _db_connection_url_here +KINETICA_USER = _login_user_here +KINETICA_PASSWD = _password_here diff --git a/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_create_llm.yaml b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_create_llm.yaml new file mode 100644 index 0000000000..56e6bbaab2 --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_create_llm.yaml @@ -0,0 +1,710 @@ +interactions: +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/status + response: + body: + string: !!binary | + BE9LADZzaG93X3N5c3RlbV9zdGF0dXNfcmVzcG9uc2X8ugEUCmdyYXBovAl7ImNvdW50Ijo4LCJz + dGF0dXMiOlt7InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjAsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzAiLCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjoxLCJob3N0 + X2lkIjoiMTcyLjMxLjMzLjMxIiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNl + cnZlcl9pZCI6MiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMiIsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjMsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzMiLCJzdGF0 + dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo0LCJob3N0X2lkIjoiMTcy + LjMxLjMzLjM0Iiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNlcnZlcl9pZCI6 + NSwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNSIsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24i + OjM5LCJzZXJ2ZXJfaWQiOjYsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzYiLCJzdGF0dXMiOiJydW5u + aW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo3LCJob3N0X2lkIjoiMTcyLjMxLjMzLjM3 + Iiwic3RhdHVzIjoicnVubmluZyJ9XX0eaGFfY2x1c3Rlcl9pbmZvzAN7ImhhX3JhbmtzX2luZm8i + Olt7InByaXZhdGVfdXJsIjoiaHR0cDovLzE3Mi4zMS4zMy4zMDo5MTkxIiwicHVibGljX3VybCI6 + Imh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MSIsImhhX3VybF9vdmVycmlkZSI6Imh0dHA6Ly8xNzIu + MzEuMzMuMzA6OTE5MSIsImFsdGVybmF0ZV91cmxzIjpbImh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5 + MSJdfV0sInJlYWR5Ijp0cnVlLCJuYW1lIjoicHJvZHVjdGlvbi1uZXcifQpob3N0c/hLeyJjb3Vu + dCI6OCwic3RhdHVzIjpbeyJ2ZXJzaW9uIjoxMzMsImhvc3RfbnVtYmVyIjowLCJpZCI6IjE3Mi4z + MS4zMy4zMCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzAtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmci + LCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9z + dGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoicnVubmluZyIsInJldmVh + bF9zdGF0dXMiOiJydW5uaW5nIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEyNjAwMzIsInN0YXJ0X3Rp + bWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4zMCJdLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiLCJHUFUtNTNlMWI3YjQt + NjhiOC1hMjhjLTEwZjMtZGI2YTA1OTdmYmI0IiwiR1BVLTQxZmY5MWZiLWVjYjktMGE1Yi1kNDdj + LWQ1YmI3ZWYxMDM4YSIsIkdQVS1hOTQwYjEyNi1iMWE0LTlmMDctNDRlMS02MzZjMzc5ODllY2Yi + XSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoibGVhZGVyIiwiaG9zdF90 + ZXJtIjowLCJob3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9u + IjoxMTMsImhvc3RfbnVtYmVyIjoxLCJpZCI6IjE3Mi4zMS4zMy4zMSIsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzEtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxl + ZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5 + X3BsYW5uZXJfc3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90 + YWxfbWVtb3J5Ijo4MTAyMDEyMzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtf + aXBzIjpbIjE3Mi4zMS4zMy4zMSJdLCJncHVfaWRzIjpbIkdQVS0xMzJmMWRkYi1hNWY0LTIwZDMt + MTEyMi02ZDM1OTlhZmNmMWQiLCJHUFUtM2JjN2JmY2QtOTVhOS1hNjI2LThlOGYtMzdiOTcxOWFh + OWRkIiwiR1BVLWZlMTBhZDNkLTg4M2QtYTU5MC1kNDA1LWUwYTU2OTNiMGFmMCIsIkdQVS02Yjgy + OTY5OS0wYjRjLTEyZjAtMGMyOC04Y2Y0NmMyNGMxODUiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZh + bHNlIiwiaG9zdF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25f + c3RhdHVzIjoibGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjIs + ImlkIjoiMTcyLjMxLjMzLjMyIiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMi12MTAwIiwic3RhdHVz + IjoicnVubmluZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVu + bmluZyIsIm1sX3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9w + cGVkIiwicmV2ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTIzMTM2 + MCwic3RhcnRfdGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjMyIl0s + ImdwdV9pZHMiOlsiR1BVLTA5MGM0NDMwLWRiYmUtMWUxYS03ZjdmLWExODI3ODNhZDIzMSIsIkdQ + VS1iZTE0YjVjZS1iNDExLTQ4Y2EtYTlmZi01YTA2YzdhNmYzOTgiLCJHUFUtNGIxYTU2ODgtMGU4 + Yy1jYzk0LTgzM2ItYzJmMzllOTk1M2I4IiwiR1BVLTEyZWJhNDYzLTgzMmUtMTA4Yi1lY2IyLTVj + OWFmOGRhNjE2NCJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xs + b3dlciIsImhvc3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3Rl + ZCJ9LHsidmVyc2lvbiI6MTEzLCJob3N0X251bWJlciI6MywiaWQiOiIxNzIuMzEuMzMuMzMiLCJo + b3N0bmFtZSI6IjMwMC0zMDMtdTMzLXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3Rh + dHVzIjoiZGlzYWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlz + YWJsZWQiLCJxdWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoi + c3RvcHBlZCIsInRvdGFsX21lbW9yeSI6ODEwMjAxMjM5NTUyLCJzdGFydF90aW1lIjoxNzA4MTAz + NDUyLCJuZXR3b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzMiXSwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImFjY2VwdHNf + ZmFpbG92ZXIiOiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJo + b3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhv + c3RfbnVtYmVyIjo0LCJpZCI6IjE3Mi4zMS4zMy4zNCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzQt + djEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRz + X3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJf + c3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5 + Ijo4MTAyMDEyMTA4ODAsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3 + Mi4zMS4zMy4zNCJdLCJncHVfaWRzIjpbIkdQVS02OGUwOWNmYy1mOWE0LTJhMTQtNTdhNC05NDgz + YjkxYzJkOWEiLCJHUFUtM2RmMjE2ZTgtZmU3NC0wNDdhLTk1YWMtNzJlMmNiZWNiNTIyIiwiR1BV + LTE0ZDQ0Yjk4LWIwNDItY2I4MS0xZGQzLTIwZDRmNjljODljYSIsIkdQVS0zNDA2NzMwYi1iZWFk + LWM1MGEtNDZlYi1lMGEyYzJiZjZlNzYiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9z + dF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoi + bGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjUsImlkIjoiMTcy + LjMxLjMzLjM1IiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNS12MTAwIiwic3RhdHVzIjoicnVubmlu + ZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVubmluZyIsIm1s + X3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9wcGVkIiwicmV2 + ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTI0Nzc0NCwic3RhcnRf + dGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjM1Il0sImdwdV9pZHMi + OlsiR1BVLWY3MzAyYWJjLTllYWEtMTRjOS1mNDI2LTE2M2RmM2RhOGMyNiIsIkdQVS03N2RkN2Q0 + OC1mOTgwLWZkMDYtNzIyYy0xYzViOTMyMTgyMDMiLCJHUFUtNTUyYjIwYTUtNTdlNi00OTg2LWJl + MmItMmIzNzhmZDRiY2FhIiwiR1BVLTYzMDUzMTYyLTMwN2YtNTVjNS1hOTc0LTU4ZGZlODQzNDJi + MiJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xsb3dlciIsImhv + c3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3RlZCJ9LHsidmVy + c2lvbiI6MTEzLCJob3N0X251bWJlciI6NiwiaWQiOiIxNzIuMzEuMzMuMzYiLCJob3N0bmFtZSI6 + IjMwMC0zMDMtdTM2LXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3RhdHVzIjoiZGlz + YWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlzYWJsZWQiLCJx + dWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoic3RvcHBlZCIs + InRvdGFsX21lbW9yeSI6ODEwMjAxMjIzMTY4LCJzdGFydF90aW1lIjoxNzA4MTAzNDUyLCJuZXR3 + b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzYiXSwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04 + MmYwLTNmZTQtZjFmMmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZk + MDA1N2FiOCIsIkdQVS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUt + YWI3NTRhM2MtNjA4Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImFjY2VwdHNfZmFpbG92ZXIi + OiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJob3N0X2VsZWN0 + aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhvc3RfbnVtYmVy + Ijo3LCJpZCI6IjE3Mi4zMS4zMy4zNyIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzctdjEwMCIsInN0 + YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6 + InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoi + c3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEy + MzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4z + NyJdLCJncHVfaWRzIjpbIkdQVS1lYTE4ZDM4OC1lMmIzLTQyODMtYTZiNS1hMzIzYTQ4NzI1YTki + LCJHUFUtZGNkODRlZmItOTRjYS1iNDk3LThjMTUtN2EzMjY5NDBjMWViIiwiR1BVLTkxNjAxYTVl + LTk3M2YtZDFlNC02ZTFkLWY2NTUyOTRkMzQ2MCIsIkdQVS0wN2ZhNGRiNi05ZTU1LWI2MWYtOTA5 + YS04NWM0ZDFiZWIwODgiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoi + Zm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoibGVhZGVyX2Vs + ZWN0ZWQifV19Fmh0dHBfc2VydmVyoAN7ImNvbm5lY3Rpb25zIjp7ImN1cnJlbnQiOjEsIm1heF9j + b25jdXJyZW50IjoxMTYsInF1ZXVlZCI6MCwibWF4X3F1ZXVlZF9hbGxvd2VkIjo2NTUzNiwidG90 + YWwiOjMyNTg5MywicmVmdXNlZCI6MCwidGhyZWFkcyI6Mn0sInRocmVhZHMiOnsidXNlZCI6Miwi + Y2FwYWNpdHkiOjUxMiwiYWxsb2NhdGVkIjo4LCJhdmFpbGFibGUiOjUxMCwic3RhY2tfc2l6ZSI6 + MH19FG1pZ3JhdGlvbnMueyJjb3VudCI6MCwic3RhdHVzIjpbXX0KcmFua3PgUnsiY291bnQiOjks + InN0YXR1cyI6W3sidmVyc2lvbiI6MTE4LCJyYW5rIjowLCJyYW5rX2lkIjoiMCA6IDE3Mi4zMS4z + My4zMCA6IDMyNzc0MDYiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmci + LCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQy + MTA5MDYiLCJwaWQiOjMyNzc0MDYsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVf + c3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGlu + Z19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1l + IjoiMzAwLTMwMy11MzAtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzAiLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiXSwiZ3B1X2luZGV4Ijow + LCJncHVfaW5kaWNlcyI6WzBdfSx7InZlcnNpb24iOjEwMiwicmFuayI6MSwicmFua19pZCI6IjEg + OiAxNzIuMzEuMzMuMzAgOiAzMjc4NTYwIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMi + OiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4x + LjIwMjQwMjE0MjEwOTA2IiwicGlkIjozMjc4NTYwLCJzdGFydF90aW1lIjoxNzA4NDQzNjU2LCJz + dGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIsInN0YXJ0X2NvdW50Ijox + LCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNl + LCJob3N0bmFtZSI6IjMwMC0zMDMtdTMwLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMwIiwi + Z3B1X2lkcyI6WyJHUFUtYTA3YzBlNDgtOTQ4YS00MDVjLTQzYjctNzM3NGQyZGRjMDhjIiwiR1BV + LTUzZTFiN2I0LTY4YjgtYTI4Yy0xMGYzLWRiNmEwNTk3ZmJiNCIsIkdQVS00MWZmOTFmYi1lY2I5 + LTBhNWItZDQ3Yy1kNWJiN2VmMTAzOGEiLCJHUFUtYTk0MGIxMjYtYjFhNC05ZjA3LTQ0ZTEtNjM2 + YzM3OTg5ZWNmIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJz + aW9uIjoxMDIsInJhbmsiOjIsInJhbmtfaWQiOiIyIDogMTcyLjMxLjMzLjMxIDogMTU0NDUxOSIs + InJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVz + Ijoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTU0 + NDUxOSwic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIw + IDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5l + d19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMS12 + MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMSIsImdwdV9pZHMiOlsiR1BVLTEzMmYxZGRiLWE1 + ZjQtMjBkMy0xMTIyLTZkMzU5OWFmY2YxZCIsIkdQVS0zYmM3YmZjZC05NWE5LWE2MjYtOGU4Zi0z + N2I5NzE5YWE5ZGQiLCJHUFUtZmUxMGFkM2QtODgzZC1hNTkwLWQ0MDUtZTBhNTY5M2IwYWYwIiwi + R1BVLTZiODI5Njk5LTBiNGMtMTJmMC0wYzI4LThjZjQ2YzI0YzE4NSJdLCJncHVfaW5kZXgiOjAs + ImdwdV9pbmRpY2VzIjpbMCwxLDIsM119LHsidmVyc2lvbiI6MTAwLCJyYW5rIjozLCJyYW5rX2lk + IjoiMyA6IDE3Mi4zMS4zMy4zMiA6IDE0Mjk2ODUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0 + YXR1cyI6InJ1bm5pbmciLCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6Ijcu + Mi4wLjEuMjAyNDAyMTQyMTA5MDYiLCJwaWQiOjE0Mjk2ODUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2 + NTYsInN0YXJ0X3RpbWVfc3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291 + bnQiOjEsImFjY2VwdGluZ19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6 + ZmFsc2UsImhvc3RuYW1lIjoiMzAwLTMwMy11MzItdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzIiLCJncHVfaWRzIjpbIkdQVS0wOTBjNDQzMC1kYmJlLTFlMWEtN2Y3Zi1hMTgyNzgzYWQyMzEi + LCJHUFUtYmUxNGI1Y2UtYjQxMS00OGNhLWE5ZmYtNWEwNmM3YTZmMzk4IiwiR1BVLTRiMWE1Njg4 + LTBlOGMtY2M5NC04MzNiLWMyZjM5ZTk5NTNiOCIsIkdQVS0xMmViYTQ2My04MzJlLTEwOGItZWNi + Mi01YzlhZjhkYTYxNjQiXSwiZ3B1X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7 + InZlcnNpb24iOjExNiwicmFuayI6NCwicmFua19pZCI6IjQgOiAxNzIuMzEuMzMuMzMgOiAxNjA4 + NzYxIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9z + dGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlk + IjoxNjA4NzYxLCJzdGFydF90aW1lIjoxNzA4NDQzNjU1LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBG + ZWIgMjAgMTU6NDA6NTUgMjAyNCIsInN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1 + ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMt + dTMzLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMzIiwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImdwdV9pbmRl + eCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjUsInJh + bmtfaWQiOiI1IDogMTcyLjMxLjMzLjM0IDogMTY2MDEwMiIsInJhbmtfbW9kZSI6InJ1biIsInJh + bmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9u + IjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTY2MDEwMiwic3RhcnRfdGltZSI6MTcw + ODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFy + dF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9v + bmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNC12MTAwIiwiaG9zdF9pZCI6IjE3Mi4z + MS4zMy4zNCIsImdwdV9pZHMiOlsiR1BVLTY4ZTA5Y2ZjLWY5YTQtMmExNC01N2E0LTk0ODNiOTFj + MmQ5YSIsIkdQVS0zZGYyMTZlOC1mZTc0LTA0N2EtOTVhYy03MmUyY2JlY2I1MjIiLCJHUFUtMTRk + NDRiOTgtYjA0Mi1jYjgxLTFkZDMtMjBkNGY2OWM4OWNhIiwiR1BVLTM0MDY3MzBiLWJlYWQtYzUw + YS00NmViLWUwYTJjMmJmNmU3NiJdLCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIs + M119LHsidmVyc2lvbiI6MTAyLCJyYW5rIjo2LCJyYW5rX2lkIjoiNiA6IDE3Mi4zMS4zMy4zNSA6 + IDEzNzk3MTUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmciLCJyZW1v + dmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQyMTA5MDYi + LCJwaWQiOjEzNzk3MTUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVfc3RyIjoi + VHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGluZ19qb2Jz + Ijp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzUtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzUiLCJncHVfaWRzIjpbIkdQVS1m + NzMwMmFiYy05ZWFhLTE0YzktZjQyNi0xNjNkZjNkYThjMjYiLCJHUFUtNzdkZDdkNDgtZjk4MC1m + ZDA2LTcyMmMtMWM1YjkzMjE4MjAzIiwiR1BVLTU1MmIyMGE1LTU3ZTYtNDk4Ni1iZTJiLTJiMzc4 + ZmQ0YmNhYSIsIkdQVS02MzA1MzE2Mi0zMDdmLTU1YzUtYTk3NC01OGRmZTg0MzQyYjIiXSwiZ3B1 + X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7InZlcnNpb24iOjEwMiwicmFuayI6 + NywicmFua19pZCI6IjcgOiAxNzIuMzEuMzMuMzYgOiAxMzc5NTM5IiwicmFua19tb2RlIjoicnVu + IiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3Zl + cnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlkIjoxMzc5NTM5LCJzdGFydF90aW1l + IjoxNzA4NDQzNjU2LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIs + InN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJy + ZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMtdTM2LXYxMDAiLCJob3N0X2lkIjoi + MTcyLjMxLjMzLjM2IiwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04MmYwLTNmZTQtZjFm + MmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZkMDA1N2FiOCIsIkdQ + VS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUtYWI3NTRhM2MtNjA4 + Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlsw + LDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjgsInJhbmtfaWQiOiI4IDogMTcyLjMxLjMz + LjM3IDogMTM5Nzg5MyIsInJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIs + InJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIx + MDkwNiIsInBpZCI6MTM5Nzg5Mywic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9z + dHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5n + X2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUi + OiIzMDAtMzAzLXUzNy12MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNyIsImdwdV9pZHMiOlsi + R1BVLWVhMThkMzg4LWUyYjMtNDI4My1hNmI1LWEzMjNhNDg3MjVhOSIsIkdQVS1kY2Q4NGVmYi05 + NGNhLWI0OTctOGMxNS03YTMyNjk0MGMxZWIiLCJHUFUtOTE2MDFhNWUtOTczZi1kMWU0LTZlMWQt + ZjY1NTI5NGQzNDYwIiwiR1BVLTA3ZmE0ZGI2LTllNTUtYjYxZi05MDlhLTg1YzRkMWJlYjA4OCJd + LCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIsM119XX0Oc3ltYm9scxZ7ImNvdW50 + IjoxfQxzeXN0ZW2qA3siaWQiOiJLaW5ldGljYSAzMDAtMzAzLXUzMC12MTAwIiwic3RhcnRfdGlt + ZSI6MTcwODEwMzQ1Miwic3RhdHVzIjoicnVubmluZyIsImNsdXN0ZXJfbGVhZGVyIjoiMTcyLjMx + LjMzLjMwIiwidmVyc2lvbiI6MjUsImNsdXN0ZXJfb3BlcmF0aW9uX3J1bm5pbmciOiJmYWxzZSIs + ImNsdXN0ZXJfb3BlcmF0aW9uX3N0YXR1cyI6IiIsIm9mZmxpbmVfc3RhdHVzIjoiZmFsc2UifQh0 + ZXh03AV7ImNvdW50Ijo4LCJzdGF0dXMiOlt7InZlcnNpb24iOjMzLCJyYW5rIjoxLCJzdGF0dXMi + OiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6Miwic3RhdHVzIjoicnVubmluZyJ9LHsi + dmVyc2lvbiI6MzMsInJhbmsiOjMsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24iOjMzLCJy + YW5rIjo0LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6NSwic3RhdHVz + IjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzMsInJhbmsiOjYsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjMzLCJyYW5rIjo3LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywi + cmFuayI6OCwic3RhdHVzIjoicnVubmluZyJ9XX0QdHJpZ2dlcnNeeyJ0b3RhbF9jb3VudCI6MCwi + cmFuZ2VfY291bnQiOjAsIm5haV9jb3VudCI6MH0AAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00073' + status: + code: 200 + message: OK +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/properties + response: + body: + string: !!binary | + BE9LAD5zaG93X3N5c3RlbV9wcm9wZXJ0aWVzX3Jlc3BvbnNlvPUCpAk8Y29uZi5haS5hcGkuY29u + bmVjdGlvbl90aW1lb3V0BDkwHmNvbmYuYWkuYXBpLmtleQAoY29uZi5haS5hcGkucHJvdmlkZXIW + a2luZXRpY2FsbG0eY29uZi5haS5hcGkudXJsSGh0dHA6Ly8xNzIuMzEuMzEuMTM6ODA1MC9zcWwv + c3VnZ2VzdDBjb25mLmFsZXJ0X2Rpc2tfYWJzb2x1dGUANGNvbmYuYWxlcnRfZGlza19wZXJjZW50 + YWdlGDEsIDUsIDEwLCAyMBxjb25mLmFsZXJ0X2V4ZQAsY29uZi5hbGVydF9ob3N0X3N0YXR1cwhU + UlVFOmNvbmYuYWxlcnRfaG9zdF9zdGF0dXNfZmlsdGVyIGZhdGFsX2luaXRfZXJyb3I4Y29uZi5h + bGVydF9tYXhfc3RvcmVkX2FsZXJ0cwYxMDA0Y29uZi5hbGVydF9tZW1vcnlfYWJzb2x1dGUAOGNv + bmYuYWxlcnRfbWVtb3J5X3BlcmNlbnRhZ2UYMSwgNSwgMTAsIDIwNGNvbmYuYWxlcnRfcmFua19j + dWRhX2Vycm9yCFRSVUVEY29uZi5hbGVydF9yYW5rX2ZhbGxiYWNrX2FsbG9jYXRvcghUUlVFLGNv + bmYuYWxlcnRfcmFua19zdGF0dXMIVFJVRTpjb25mLmFsZXJ0X3Jhbmtfc3RhdHVzX2ZpbHRlclhm + YXRhbF9pbml0X2Vycm9yLCBub3RfcmVzcG9uZGluZywgdGVybWluYXRlZB5jb25mLmF1ZGl0X2Jv + ZHkKRkFMU0UeY29uZi5hdWRpdF9kYXRhCkZBTFNFJGNvbmYuYXVkaXRfaGVhZGVycwpGQUxTRT5j + b25mLmF1dG9fY3JlYXRlX2V4dGVybmFsX3VzZXJzCkZBTFNFTGNvbmYuYnVpbGRfbWF0ZXJpYWxp + emVkX3ZpZXdzX29uX3N0YXJ0Em9uX2RlbWFuZDhjb25mLmJ1aWxkX3BrX2luZGV4X29uX3N0YXJ0 + Em9uX2RlbWFuZDhjb25mLmNodW5rX2NvbHVtbl9tYXhfbWVtb3J5EjUxMjAwMDAwMCpjb25mLmNo + dW5rX21heF9tZW1vcnkUODE5MjAwMDAwMB5jb25mLmNodW5rX3NpemUOODAwMDAwMCJjb25mLmNs + dXN0ZXJfbmFtZRxwcm9kdWN0aW9uLW5ld0Bjb25mLmNvbmN1cnJlbnRfa2VybmVsX2V4ZWN1dGlv + bghUUlVFOmNvbmYuZGVmYXVsdF9wcmltYXJ5X2tleV90eXBlDG1lbW9yeSBjb25mLmRlZmF1bHRf + dHRsBDIwLGNvbmYuZGlzYWJsZV9jbGVhcl9hbGwIVFJVRT5jb25mLmVncmVzc19wYXJxdWV0X2Nv + bXByZXNzaW9uDHNuYXBweSRjb25mLmVuYWJsZV9hbGVydHMIVFJVRSJjb25mLmVuYWJsZV9hdWRp + dApGQUxTRTJjb25mLmVuYWJsZV9hdXRob3JpemF0aW9uCFRSVUVGY29uZi5lbmFibGVfZXh0ZXJu + YWxfYXV0aGVudGljYXRpb24KRkFMU0UwY29uZi5lbmFibGVfZ3JhcGhfc2VydmVyCFRSVUUcY29u + Zi5lbmFibGVfaGEKRkFMU0UuY29uZi5lbmFibGVfaHR0cGRfcHJveHkKRkFMU0UcY29uZi5lbmFi + bGVfbWwKRkFMU0U2Y29uZi5lbmFibGVfb3BlbmdsX3JlbmRlcmVyCFRSVUVAY29uZi5lbmFibGVf + b3ZlcmxhcHBlZF9lcXVpX2pvaW4IVFJVRTRjb25mLmVuYWJsZV9wb3N0Z3Jlc19wcm94eQhUUlVF + PmNvbmYuZW5hYmxlX3ByZWRpY2F0ZV9lcXVpX2pvaW4IVFJVRSJjb25mLmVuYWJsZV9wcm9jcwhU + UlVFJGNvbmYuZW5hYmxlX3JldmVhbAhUUlVFMGNvbmYuZW5hYmxlX3N0YXRzX3NlcnZlcghUUlVF + LmNvbmYuZW5hYmxlX3RleHRfc2VhcmNoCFRSVUU8Y29uZi5lbmFibGVfdmVjdG9ydGlsZV9zZXJ2 + aWNlCFRSVUUsY29uZi5lbmFibGVfdnJhbV9jYWNoZQhUUlVFPmNvbmYuZW5hYmxlX3dvcmtlcl9o + dHRwX3NlcnZlcnMIVFJVRTJjb25mLmV2ZW50X3NlcnZlcl9hZGRyZXNzGDE3Mi4zMS4zMy4zMDRj + b25mLmV2ZW50X3NlcnZlcl9pbnRlcm5hbApGQUxTRTpjb25mLmV4dGVybmFsX2ZpbGVzX2RpcmVj + dG9yeSAvbmZzL2RhdGEvcHVibGljFGNvbmYuZ21faXAYMTcyLjMxLjMzLjMwGmNvbmYuZ21fcG9y + dDEINTU1MiBjb25mLmdtX3B1Yl9wb3J0CDU1NTMoY29uZi5ncmFwaC5oZWFkX3BvcnQIODEwMC5j + b25mLmdyYXBoLnNlcnZlcjAuaG9zdApob3N0MC5jb25mLmdyYXBoLnNlcnZlcjAucG9ydAg4MTAx + OGNvbmYuZ3JhcGguc2VydmVyMC5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjEuaG9zdApo + b3N0MS5jb25mLmdyYXBoLnNlcnZlcjEucG9ydAg4MTAyOGNvbmYuZ3JhcGguc2VydmVyMS5yYW1f + bGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjIuaG9zdApob3N0Mi5jb25mLmdyYXBoLnNlcnZlcjIu + cG9ydAg4MTAzOGNvbmYuZ3JhcGguc2VydmVyMi5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZl + cjMuaG9zdApob3N0My5jb25mLmdyYXBoLnNlcnZlcjMucG9ydAg4MTA0OGNvbmYuZ3JhcGguc2Vy + dmVyMy5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjQuaG9zdApob3N0NC5jb25mLmdyYXBo + LnNlcnZlcjQucG9ydAg4MTA1OGNvbmYuZ3JhcGguc2VydmVyNC5yYW1fbGltaXQCMC5jb25mLmdy + YXBoLnNlcnZlcjUuaG9zdApob3N0NS5jb25mLmdyYXBoLnNlcnZlcjUucG9ydAg4MTA2OGNvbmYu + Z3JhcGguc2VydmVyNS5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjYuaG9zdApob3N0Ni5j + b25mLmdyYXBoLnNlcnZlcjYucG9ydAg4MTA3OGNvbmYuZ3JhcGguc2VydmVyNi5yYW1fbGltaXQC + MC5jb25mLmdyYXBoLnNlcnZlcjcuaG9zdApob3N0Ny5jb25mLmdyYXBoLnNlcnZlcjcucG9ydAg4 + MTA4OGNvbmYuZ3JhcGguc2VydmVyNy5yYW1fbGltaXQCMBxjb25mLmhhX3F1ZXVlcwAuY29uZi5o + YV9yaW5nX2hlYWRfbm9kZXMAKGNvbmYuaGVhZF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zMBxjb25m + LmhlYWRfcG9ydAg5MTkxImNvbmYuaG1faHR0cF9wb3J0CDkzMDA2Y29uZi5ob3N0MF9hY2NlcHRz + X2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDBfYWRkcmVzcxgxNzIuMzEuMzMuMzAeY29uZi5ob3N0 + MF9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8v + MTcyLjMxLjMzLjMwOjkzMDAsY29uZi5ob3N0MF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMz + LjMwMmNvbmYuaG9zdDBfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMwLGNvbmYuaG9zdDBfcHVi + bGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMChjb25mLmhvc3QwX3JhbV9saW1pdBg2NTY3Njc3 + OTk5OTk2Y29uZi5ob3N0MV9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDFfYWRkcmVz + cxgxNzIuMzEuMzMuMzEeY29uZi5ob3N0MV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MV9ob3N0X21h + bmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMxOjkzMDAsY29uZi5ob3N0MV9wcml2 + YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMxMmNvbmYuaG9zdDFfcHVibGljX2FkZHJlc3MYMTcy + LjMxLjMzLjMxLGNvbmYuaG9zdDFfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMShjb25m + Lmhvc3QxX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0Ml9hY2NlcHRzX2ZhaWxvdmVy + CkZBTFNFJGNvbmYuaG9zdDJfYWRkcmVzcxgxNzIuMzEuMzMuMzIeY29uZi5ob3N0Ml9ncHVzDjAs + MSwyLDNEY29uZi5ob3N0Ml9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMz + LjMyOjkzMDAsY29uZi5ob3N0Ml9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMyMmNvbmYu + aG9zdDJfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMyLGNvbmYuaG9zdDJfcHVibGljX3VybHMm + aHR0cDovLzE3Mi4zMS4zMy4zMihjb25mLmhvc3QyX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29u + Zi5ob3N0M19hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDNfYWRkcmVzcxgxNzIuMzEu + MzMuMzMeY29uZi5ob3N0M19ncHVzDjAsMSwyLDNEY29uZi5ob3N0M19ob3N0X21hbmFnZXJfcHVi + bGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMzOjkzMDAsY29uZi5ob3N0M19wcml2YXRlX3VybCZo + dHRwOi8vMTcyLjMxLjMzLjMzMmNvbmYuaG9zdDNfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMz + LGNvbmYuaG9zdDNfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMyhjb25mLmhvc3QzX3Jh + bV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NF9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNv + bmYuaG9zdDRfYWRkcmVzcxgxNzIuMzEuMzMuMzQeY29uZi5ob3N0NF9ncHVzDjAsMSwyLDNEY29u + Zi5ob3N0NF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM0OjkzMDAs + Y29uZi5ob3N0NF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM0MmNvbmYuaG9zdDRfcHVi + bGljX2FkZHJlc3MYMTcyLjMxLjMzLjM0LGNvbmYuaG9zdDRfcHVibGljX3VybHMmaHR0cDovLzE3 + Mi4zMS4zMy4zNChjb25mLmhvc3Q0X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NV9h + Y2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDVfYWRkcmVzcxgxNzIuMzEuMzMuMzUeY29u + Zi5ob3N0NV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0NV9ob3N0X21hbmFnZXJfcHVibGljX3VybDBo + dHRwOi8vMTcyLjMxLjMzLjM1OjkzMDAsY29uZi5ob3N0NV9wcml2YXRlX3VybCZodHRwOi8vMTcy + LjMxLjMzLjM1MmNvbmYuaG9zdDVfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM1LGNvbmYuaG9z + dDVfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNShjb25mLmhvc3Q1X3JhbV9saW1pdBg2 + NTY3Njc3OTk5OTk2Y29uZi5ob3N0Nl9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDZf + YWRkcmVzcxgxNzIuMzEuMzMuMzYeY29uZi5ob3N0Nl9ncHVzDjAsMSwyLDNEY29uZi5ob3N0Nl9o + b3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM2OjkzMDAsY29uZi5ob3N0 + Nl9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM2MmNvbmYuaG9zdDZfcHVibGljX2FkZHJl + c3MYMTcyLjMxLjMzLjM2LGNvbmYuaG9zdDZfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4z + Nihjb25mLmhvc3Q2X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0N19hY2NlcHRzX2Zh + aWxvdmVyCkZBTFNFJGNvbmYuaG9zdDdfYWRkcmVzcxgxNzIuMzEuMzMuMzceY29uZi5ob3N0N19n + cHVzDjAsMSwyLDNEY29uZi5ob3N0N19ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcy + LjMxLjMzLjM3OjkzMDAsY29uZi5ob3N0N19wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM3 + MmNvbmYuaG9zdDdfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM3LGNvbmYuaG9zdDdfcHVibGlj + X3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNyhjb25mLmhvc3Q3X3JhbV9saW1pdBg2NTY3Njc3OTk5 + OTkqY29uZi5odHRwZF9wcm94eV9wb3J0CDgwODI0Y29uZi5odHRwZF9wcm94eV91c2VfaHR0cHMK + RkFMU0U4Y29uZi5pbml0X3dpdGhfbm93X2F0X3dvcmtlcgpGQUxTRSpjb25mLmthZmthLmJhdGNo + X3NpemUIMTAwMC5jb25mLmthZmthLnBvbGxfdGltZW91dAIwKGNvbmYua2Fma2Eud2FpdF90aW1l + BDMwLmNvbmYua2VybmVsX29tcF90aHJlYWRzAjQ0Y29uZi5sb2FkX3ZlY3RvcnNfb25fc3RhcnQS + b25fZGVtYW5kHmNvbmYubG9ja19hdWRpdApGQUxTRTZjb25mLm1heF9hdXRvX3ZpZXdfdXBkYXRv + cnMCMzZjb25mLm1heF9jb25jdXJyZW50X2tlcm5lbHMCMDJjb25mLm1heF9nZXRfcmVjb3Jkc19z + aXplCjIwMDAwKmNvbmYubWF4X2hlYXRtYXBfc2l6ZQgzMDcyKmNvbmYubWF4X2h0dHBfdGhyZWFk + cwY1MTI6Y29uZi5tZXRhZGF0YV9zdG9yZV9zeW5jX21vZGUMbm9ybWFsKmNvbmYubWluX2h0dHBf + dGhyZWFkcwI4MGNvbmYubWluX3Bhc3N3b3JkX2xlbmd0aAIwIGNvbmYubWxfYXBpX3BvcnQIOTE4 + N1xjb25mLm5wMS5idWlsZF9tYXRlcmlhbGl6ZWRfdmlld3Nfb25fbWlncmF0aW9uDGFsd2F5c0hj + b25mLm5wMS5idWlsZF9wa19pbmRleF9vbl9taWdyYXRpb24MYWx3YXlzRGNvbmYubnAxLmNyaXRp + Y2FsX3Jlc3RhcnRfYXR0ZW1wdHMCMTpjb25mLm5wMS5lbmFibGVfaGVhZF9mYWlsb3ZlcgpGQUxT + RT5jb25mLm5wMS5lbmFibGVfd29ya2VyX2ZhaWxvdmVyCkZBTFNFSmNvbmYubnAxLmZhaWxvdmVy + X2Rpc3RyaWJ1dGlvbl9wb2xpY3kIZmlsbERjb25mLm5wMS5sb2FkX3ZlY3RvcnNfb25fbWlncmF0 + aW9uDGFsd2F5c0xjb25mLm5wMS5ub25fY3JpdGljYWxfcmVzdGFydF9hdHRlbXB0cwIzPGNvbmYu + bnAxLnJhbmtfcmVzdGFydF9hdHRlbXB0cwIxMmNvbmYubnAxLnJlc3RhcnRfaW50ZXJ2YWwENjA2 + Y29uZi5ucDEuc3RvcmFnZV9hcGlfc2NyaXB0AChjb25mLm51bWJlcl9vZl9ob3N0cwI4KGNvbmYu + bnVtYmVyX29mX3JhbmtzAjk8Y29uZi5vcGVuZ2xfYW50aWFsaWFzaW5nX2xldmVsAjAsY29uZi5w + ZXJzaXN0X2RpcmVjdG9yeTAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8sY29uZi5wZXJzaXN0X3N5 + bmNfdGltZQI1NmNvbmYucG9pbnRfcmVuZGVyX3RocmVzaG9sZAwxMDAwMDBWY29uZi5wb3N0Z3Jl + c19wcm94eS5pZGxlX2Nvbm5lY3Rpb25fdGltZW91dAYzMDBUY29uZi5wb3N0Z3Jlc19wcm94eS5t + YXhfcXVldWVkX2Nvbm5lY3Rpb25zAjE+Y29uZi5wb3N0Z3Jlc19wcm94eS5tYXhfdGhyZWFkcwQ2 + ND5jb25mLnBvc3RncmVzX3Byb3h5Lm1pbl90aHJlYWRzAjIwY29uZi5wb3N0Z3Jlc19wcm94eS5w + b3J0CDU0MzIuY29uZi5wb3N0Z3Jlc19wcm94eS5zc2wIVFJVRRxjb25mLnJhbmswX2dwdQIwKmNv + bmYucmFuazBfaXBfYWRkcmVzcxgxNzIuMzEuMzMuMzAqY29uZi5yYW5rMV9pcF9hZGRyZXNzGDE3 + Mi4zMS4zMy4zMCpjb25mLnJhbmsyX2lwX2FkZHJlc3MYMTcyLjMxLjMzLjMxKmNvbmYucmFuazNf + aXBfYWRkcmVzcxgxNzIuMzEuMzMuMzIqY29uZi5yYW5rNF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4z + Mypjb25mLnJhbms1X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM0KmNvbmYucmFuazZfaXBfYWRkcmVz + cxgxNzIuMzEuMzMuMzUqY29uZi5yYW5rN19pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zNipjb25mLnJh + bms4X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM3KGNvbmYucmVxdWVzdF90aW1lb3V0CDI0MDA2Y29u + Zi5yZXF1aXJlX2F1dGhlbnRpY2F0aW9uCFRSVUVeY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0 + Lm1heF9jcHVfY29uY3VycmVuY3kELTFaY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0Lm1heF90 + aWVyX3ByaW9yaXR5BDEwSmNvbmYucmVzb3VyY2VfZ3JvdXAuZGVmYXVsdC5yYW1fbGltaXQELTFa + Y29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0LnNjaGVkdWxlX3ByaW9yaXR5BDUwTGNvbmYucmVz + b3VyY2VfZ3JvdXAuZGVmYXVsdC52cmFtX2xpbWl0BC0xHGNvbmYucmluZ19uYW1lDmRlZmF1bHRW + Y29uZi5zZWN1cml0eS5leHRlcm5hbC5yYW5nZXIuY2FjaGVfbWludXRlcwQ2MFRjb25mLnNlY3Vy + aXR5LmV4dGVybmFsLnJhbmdlci5zZXJ2aWNlX25hbWUQa2luZXRpY2FCY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXIudXJsAGBjb25mLnNlY3VyaXR5LmV4dGVybmFsLnJhbmdlcl9hdXRob3Jp + emVyLmFkZHJlc3MyaXBjOi8vL3RtcC9ncHVkYi1yYW5nZXItMHRjb25mLnNlY3VyaXR5LmV4dGVy + bmFsLnJhbmdlcl9hdXRob3JpemVyLnJlbW90ZV9kZWJ1Z19wb3J0AjBgY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXJfYXV0aG9yaXplci50aW1lb3V0BjEyMCpjb25mLnNldF9tb25pdG9yX3Bv + cnQIOTAwMjZjb25mLnNldF9tb25pdG9yX3Byb3h5X3BvcnQIOTAwMzZjb25mLnNldF9tb25pdG9y + X3F1ZXVlX3NpemUIMTAwMChjb25mLnNoYWRvd19hZ2dfc2l6ZRI1MDAwMDAwMDAwY29uZi5zaGFk + b3dfY3ViZV9lbmFibGVkCFRSVUUuY29uZi5zaGFkb3dfZmlsdGVyX3NpemUSNTAwMDAwMDAwJmNv + bmYuc21fb21wX3RocmVhZHMCMiRjb25mLnNtc19kaXJlY3RvcnkwL21udC9kYXRhL2dwdWRiL3Bl + cnNpc3QvLmNvbmYuc21zX21heF9vcGVuX2ZpbGVzBjEyOEBjb25mLnNxbC5jb3N0X2Jhc2VkX29w + dGltaXphdGlvbgpGQUxTRTRjb25mLnNxbC5kaXN0cmlidXRlZF9qb2lucwhUUlVFPmNvbmYuc3Fs + LmRpc3RyaWJ1dGVkX29wZXJhdGlvbnMIVFJVRS5jb25mLnNxbC5lbmFibGVfcGxhbm5lcghUUlVF + NmNvbmYuc3FsLmZvcmNlX2JpbmFyeV9qb2lucwpGQUxTRTpjb25mLnNxbC5mb3JjZV9iaW5hcnlf + c2V0X29wcwpGQUxTRTZjb25mLnNxbC5tYXhfcGFyYWxsZWxfc3RlcHMCNEBjb25mLnNxbC5tYXhf + dmlld19uZXN0aW5nX2xldmVscwQxNjJjb25mLnNxbC5wYWdpbmdfdGFibGVfdHRsBDIwNmNvbmYu + c3FsLnBhcmFsbGVsX2V4ZWN1dGlvbghUUlVFMGNvbmYuc3FsLnBsYW5fY2FjaGVfc2l6ZQg0MDAw + MGNvbmYuc3FsLnBsYW5uZXIuYWRkcmVzcz5pcGM6Ly8vdG1wL2dwdWRiLXF1ZXJ5LWVuZ2luZS0w + NmNvbmYuc3FsLnBsYW5uZXIubWF4X21lbW9yeQg0MDk2NGNvbmYuc3FsLnBsYW5uZXIubWF4X3N0 + YWNrAjZEY29uZi5zcWwucGxhbm5lci5yZW1vdGVfZGVidWdfcG9ydAIwMGNvbmYuc3FsLnBsYW5u + ZXIudGltZW91dAYxMjA0Y29uZi5zcWwucmVzdWx0X2NhY2hlX3NpemUINDAwMDRjb25mLnNxbC5y + ZXN1bHRzLmNhY2hlX3R0bAQ2MDBjb25mLnNxbC5yZXN1bHRzLmNhY2hpbmcIVFJVRUBjb25mLnNx + bC5ydWxlX2Jhc2VkX29wdGltaXphdGlvbghUUlVFPGNvbmYuc3VidGFza19jb25jdXJyZW5jeV9s + aW1pdAI0PmNvbmYuc3ltYm9sb2d5X3JlbmRlcl90aHJlc2hvbGQKMTAwMDBQY29uZi5zeXN0ZW1f + bWV0YWRhdGEuc3RhdHNfYWdncl9yb3djb3VudAoxMDAwMEhjb25mLnN5c3RlbV9tZXRhZGF0YS5z + dGF0c19hZ2dyX3RpbWUCMVJjb25mLnN5c3RlbV9tZXRhZGF0YS5zdGF0c19yZXRlbnRpb25fZGF5 + cwQyMSZjb25mLnRhc2tjYWxjX2dwdS4xElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4yElsw + LDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4zElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS40 + ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS41ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dw + dS42ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS43ElswLDEsMiwzXSZjb25mLnRhc2tjYWxj + X2dwdS44ElswLDEsMiwzXSBjb25mLnRjc19wZXJfdG9tBDQwJmNvbmYudGVtcF9kaXJlY3RvcnkI + L3RtcDJjb25mLnRleHRfaW5kZXhfZGlyZWN0b3J5MC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0LzJj + b25mLnRleHRfaW5kaWNlc19wZXJfdG9tAjJMY29uZi50aWVyLmRpc2swLmRlZmF1bHQuaGlnaF93 + YXRlcm1hcmsEOTA6Y29uZi50aWVyLmRpc2swLmRlZmF1bHQubGltaXQYNjAwMDAwMDAwMDAwSmNv + bmYudGllci5kaXNrMC5kZWZhdWx0Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLmRpc2swLmRl + ZmF1bHQucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlYGNvbmYudGllci5k + aXNrMC5kZWZhdWx0LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlz + azAucmFuazAuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbmswLmxpbWl0GDYw + MDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazAubG93X3dhdGVybWFyawQ4MDRjb25mLnRp + ZXIuZGlzazAucmFuazAucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNv + bmYudGllci5kaXNrMC5yYW5rMC5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50 + aWVyLmRpc2swLnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rMS5s + aW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJhbmsxLmxvd193YXRlcm1hcmsEODA0 + Y29uZi50aWVyLmRpc2swLnJhbmsxLnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tj + YWNoZVxjb25mLnRpZXIuZGlzazAucmFuazEuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNF + SGNvbmYudGllci5kaXNrMC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAu + cmFuazIubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rMi5sb3dfd2F0ZXJt + YXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rMi5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0 + Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbmsyLnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0 + cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazMuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVy + LmRpc2swLnJhbmszLmxpbWl0GDYwMDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazMubG93 + X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazMucGF0aEQvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5yYW5rMy5zdG9yZV9wZXJzaXN0ZW50 + X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNv + bmYudGllci5kaXNrMC5yYW5rNC5saW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJh + bms0Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2swLnJhbms0LnBhdGhEL21udC9kYXRh + L2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIuZGlzazAucmFuazQuc3RvcmVfcGVy + c2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNrMC5yYW5rNS5oaWdoX3dhdGVybWFy + awQ5MDZjb25mLnRpZXIuZGlzazAucmFuazUubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5k + aXNrMC5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rNS5wYXRoRC9t + bnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbms1LnN0 + b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazYuaGlnaF93 + YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbms2LmxpbWl0GDYwMDAwMDAwMDAwMEZjb25m + LnRpZXIuZGlzazAucmFuazYubG93X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazYu + cGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5y + YW5rNi5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms3 + LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rNy5saW1pdBg2MDAwMDAwMDAw + MDBGY29uZi50aWVyLmRpc2swLnJhbms3Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2sw + LnJhbms3LnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIu + ZGlzazAucmFuazcuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNr + MC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAucmFuazgubGltaXQYNjAw + MDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGll + ci5kaXNrMC5yYW5rOC5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29u + Zi50aWVyLmRpc2swLnJhbms4LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRVBjb25mLnRp + ZXIuZ2xvYmFsLmNvbmN1cnJlbnRfd2FpdF90aW1lb3V0BjYwMGpjb25mLnRpZXIuZ2xvYmFsLmRl + ZmVyX2NhY2hlX29iamVjdF9ldmljdGlvbnNfdG9fZGlzawhUUlVFUGNvbmYudGllci5wZXJzaXN0 + LmRlZmF1bHQuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnBlcnNpc3QuZGVmYXVsdC5saW1p + dBo2NTAwMDAwMDAwMDAwTmNvbmYudGllci5wZXJzaXN0LmRlZmF1bHQubG93X3dhdGVybWFyawQ4 + MDxjb25mLnRpZXIucGVyc2lzdC5kZWZhdWx0LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3Qv + OmNvbmYudGllci5wZXJzaXN0LmdyYXBoMC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpj + b25mLnRpZXIucGVyc2lzdC5ncmFwaDEucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29u + Zi50aWVyLnBlcnNpc3QuZ3JhcGgyLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYu + dGllci5wZXJzaXN0LmdyYXBoMy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRp + ZXIucGVyc2lzdC5ncmFwaDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29uZi50aWVy + LnBlcnNpc3QuZ3JhcGg1LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYudGllci5w + ZXJzaXN0LmdyYXBoNi5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRpZXIucGVy + c2lzdC5ncmFwaDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNp + c3QucmFuazAuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazAubGltaXQa + NjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwOGNv + bmYudGllci5wZXJzaXN0LnJhbmswLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYu + dGllci5wZXJzaXN0LnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJh + bmsxLmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazEubG93X3dhdGVy + bWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rMS5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJz + aXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIu + cGVyc2lzdC5yYW5rMi5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbmsy + Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazIucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNpc3QucmFuazMuaGlnaF93YXRlcm1hcmsEOTA6 + Y29uZi50aWVyLnBlcnNpc3QucmFuazMubGltaXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVy + c2lzdC5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwOGNvbmYudGllci5wZXJzaXN0LnJhbmszLnBhdGgw + L21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYudGllci5wZXJzaXN0LnJhbms0LmhpZ2hfd2F0 + ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJhbms0LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29u + Zi50aWVyLnBlcnNpc3QucmFuazQubG93X3dhdGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5y + YW5rNC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5r + NS5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIucGVyc2lzdC5yYW5rNS5saW1pdBo2NTAwMDAw + MDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbms1Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVy + LnBlcnNpc3QucmFuazUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBl + cnNpc3QucmFuazYuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazYubGlt + aXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgw + OGNvbmYudGllci5wZXJzaXN0LnJhbms2LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNv + bmYudGllci5wZXJzaXN0LnJhbms3LmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0 + LnJhbms3LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazcubG93X3dh + dGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rNy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9w + ZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRp + ZXIucGVyc2lzdC5yYW5rOC5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJh + bms4Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazgucGF0aDAvbW50L2Rh + dGEvZ3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDEucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDIucGF0aDAvbW50L2RhdGEvZ3B1 + ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDMucGF0aDAvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVy + c2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lz + dC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDYucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84 + Y29uZi50aWVyLnBlcnNpc3QudGV4dDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84Y29u + Zi50aWVyLnBlcnNpc3QudGV4dDgucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9IY29uZi50 + aWVyLnJhbS5kZWZhdWx0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5yYW0uZGVmYXVsdC5s + aW1pdAQtMUZjb25mLnRpZXIucmFtLmRlZmF1bHQubG93X3dhdGVybWFyawQ4MERjb25mLnRpZXIu + cmFtLnJhbmswLmhpZ2hfd2F0ZXJtYXJrBDkwMmNvbmYudGllci5yYW0ucmFuazAubGltaXQWNzcy + NjY4MDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazEuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazIuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazMuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazQuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazUuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazYuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazcuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazguaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rOC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwXGNvbmYudGllci52 + cmFtLmRlZmF1bHQuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBKY29uZi50aWVyLnZyYW0uZGVm + YXVsdC5hbGxfZ3B1cy5saW1pdAQtMVpjb25mLnRpZXIudnJhbS5kZWZhdWx0LmFsbF9ncHVzLmxv + d193YXRlcm1hcmsEODBUY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUwLmhpZ2hfd2F0ZXJtYXJr + BDkwQmNvbmYudGllci52cmFtLmRlZmF1bHQuZ3B1MC5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5k + ZWZhdWx0LmdwdTAubG93X3dhdGVybWFyawQ4MFRjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTEu + aGlnaF93YXRlcm1hcmsEOTBCY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUxLmxpbWl0BC0xUmNv + bmYudGllci52cmFtLmRlZmF1bHQuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwVGNvbmYudGllci52cmFt + LmRlZmF1bHQuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MEJjb25mLnRpZXIudnJhbS5kZWZhdWx0Lmdw + dTIubGltaXQELTFSY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUyLmxvd193YXRlcm1hcmsEODBU + Y29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwQmNvbmYudGllci52 + cmFtLmRlZmF1bHQuZ3B1My5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTMubG93 + X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMC5HUFUwLmhpZ2hfd2F0ZXJtYXJrBDkw + PmNvbmYudGllci52cmFtLnJhbmswLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAu + R1BVMC5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmhpZ2hf + d2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYu + dGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazAuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUwLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rMC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsw + LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbmswLmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazAuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUyLmxvd193YXRl + cm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25m + LnRpZXIudnJhbS5yYW5rMC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTMu + bG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5HUFUwLmhpZ2hfd2F0ZXJtYXJr + BDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFu + azEuR1BVMC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLkdQVTEuaGlnaF93 + YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuR1BVMS5saW1pdAQtMU5jb25mLnRpZXIu + dnJhbS5yYW5rMS5HUFUxLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuR1BV + Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5HUFUyLmxpbWl0BC0xTmNv + bmYudGllci52cmFtLnJhbmsxLkdQVTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5y + YW5rMS5HUFUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTMubGlt + aXQELTFOY29uZi50aWVyLnZyYW0ucmFuazEuR1BVMy5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGll + ci52cmFtLnJhbmsxLmFsbF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJh + bmsxLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGllci52cmFtLnJhbmsxLmFsbF9ncHVzLmxvd193 + YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5j + b25mLnRpZXIudnJhbS5yYW5rMS5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsxLmdw + dTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5ncHUxLmhpZ2hfd2F0ZXJt + YXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0u + cmFuazEuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLmdwdTIuaGln + aF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuZ3B1Mi5saW1pdAQtMU5jb25mLnRp + ZXIudnJhbS5yYW5rMS5ncHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEu + Z3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5ncHUzLmxpbWl0BC0x + TmNvbmYudGllci52cmFtLnJhbmsxLmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJh + bS5yYW5rMi5hbGxfZ3B1cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rMi5h + bGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJhbS5yYW5rMi5hbGxfZ3B1cy5sb3dfd2F0ZXJt + YXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50 + aWVyLnZyYW0ucmFuazIuZ3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUwLmxv + d193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazIuZ3B1MS5oaWdoX3dhdGVybWFyawQ5 + MD5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsy + LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMi5ncHUyLmhpZ2hfd2F0 + ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsyLmdwdTIubGltaXQELTFOY29uZi50aWVyLnZy + YW0ucmFuazIuZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTMu + aGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazIuZ3B1My5saW1pdAQtMU5jb25m + LnRpZXIudnJhbS5yYW5rMi5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFu + azMuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dw + dXMubGltaXQELTFWY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4 + MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52 + cmFtLnJhbmszLmdwdTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1MC5sb3dfd2F0 + ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmszLmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29u + Zi50aWVyLnZyYW0ucmFuazMuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUx + Lmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1Mi5oaWdoX3dhdGVybWFy + awQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJh + bmszLmdwdTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUzLmhpZ2hf + d2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmszLmdwdTMubGltaXQELTFOY29uZi50aWVy + LnZyYW0ucmFuazMuZ3B1My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms0LmFs + bF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxp + bWl0BC0xVmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29u + Zi50aWVyLnZyYW0ucmFuazQuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5y + YW5rNC5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms0LmdwdTAubG93X3dhdGVybWFy + awQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGll + ci52cmFtLnJhbms0LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1MS5sb3df + d2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms0LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+ + Y29uZi50aWVyLnZyYW0ucmFuazQuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNC5n + cHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1My5oaWdoX3dhdGVy + bWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFt + LnJhbms0LmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1 + cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5saW1pdAQt + MVZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGll + ci52cmFtLnJhbms1LmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazUu + Z3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNS5ncHUwLmxvd193YXRlcm1hcmsEODBQ + Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJh + bS5yYW5rNS5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms1LmdwdTEubG93X3dhdGVy + bWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNS5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYu + dGllci52cmFtLnJhbms1LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazUuZ3B1Mi5s + b3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms1LmdwdTMuaGlnaF93YXRlcm1hcmsE + OTA+Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5r + NS5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMuaGln + aF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubGltaXQELTFWY29u + Zi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJh + bS5yYW5rNi5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms2LmdwdTAu + bGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1MC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYu + dGllci52cmFtLnJhbms2LmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFu + azYuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNi5ncHUxLmxvd193YXRlcm1hcmsE + ODBQY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIu + dnJhbS5yYW5rNi5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms2LmdwdTIubG93X3dh + dGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNi5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNv + bmYudGllci52cmFtLnJhbms2LmdwdTMubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1 + My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmhpZ2hfd2F0 + ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGll + ci52cmFtLnJhbms3LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFu + azcuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUwLmxpbWl0 + BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIu + dnJhbS5yYW5rNy5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms3Lmdw + dTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNv + bmYudGllci52cmFtLnJhbms3LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0u + cmFuazcuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUyLmxvd193YXRlcm1h + cmsEODBQY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRp + ZXIudnJhbS5yYW5rNy5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTMubG93 + X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5oaWdoX3dhdGVybWFy + awQ5MEZjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJh + bS5yYW5rOC5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms4Lmdw + dTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazguZ3B1MC5saW1pdAQtMU5j + b25mLnRpZXIudnJhbS5yYW5rOC5ncHUwLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazguZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUxLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbms4LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rOC5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms4 + LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazguZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbms4LmdwdTMuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazguZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUzLmxvd193YXRl + cm1hcmsEODA0Y29uZi50aWVyX3N0cmF0ZWd5LmRlZmF1bHRCVlJBTSAyLCBSQU0gNSwgRElTSzAg + NSwgUEVSU0lTVCA1YGNvbmYudGllcl9zdHJhdGVneS5wcmVkaWNhdGVfZXZhbHVhdGlvbl9pbnRl + cnZhbAQ2MCRjb25mLnRvbXNfcGVyX3JhbmsCMSBjb25mLnRwc19wZXJfdG9tBDQwImNvbmYudHJp + Z2dlcl9wb3J0CDkwMDE+Y29uZi51bmlmaWVkX3NlY3VyaXR5X25hbWVzcGFjZQpGQUxTRTpjb25m + LnVzZV9leHRlcm5hbF90ZXh0X3NlcnZlcghUUlVFHGNvbmYudXNlX2h0dHBzCkZBTFNFLGNvbmYu + dmlkZW9fZGVmYXVsdF90dGwELTEoY29uZi52aWRlb19tYXhfY291bnQELTEyY29uZi52aWRlb190 + ZW1wX2RpcmVjdG9yeSwvdG1wL2dwdWRiLXRlbXAtdmlkZW9zImNvbmYud2FsLmNoZWNrc3VtCFRS + VUUwY29uZi53YWwuZmx1c2hfZnJlcXVlbmN5BDYwMmNvbmYud2FsLm1heF9zZWdtZW50X3NpemUS + NTAwMDAwMDAwLGNvbmYud2FsLnNlZ21lbnRfY291bnQELTEoY29uZi53YWwuc3luY19wb2xpY3kK + Zmx1c2g2Y29uZi53b3JrZXJfaHR0cF9zZXJ2ZXJfaXBz6AExNzIuMzEuMzMuMzA7MTcyLjMxLjMz + LjMwOzE3Mi4zMS4zMy4zMTsxNzIuMzEuMzMuMzI7MTcyLjMxLjMzLjMzOzE3Mi4zMS4zMy4zNDsx + NzIuMzEuMzMuMzU7MTcyLjMxLjMzLjM2OzE3Mi4zMS4zMy4zNzpjb25mLndvcmtlcl9odHRwX3Nl + cnZlcl9wb3J0c1g5MTkxOzkxOTI7OTE5Mzs5MTk0OzkxOTU7OTE5Njs5MTk3OzkxOTg7OTE5OThj + b25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzwANodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTE7aHR0 + cDovLzE3Mi4zMS4zMy4zMDo5MTkyO2h0dHA6Ly8xNzIuMzEuMzMuMzE6OTE5MztodHRwOi8vMTcy + LjMxLjMzLjMyOjkxOTQ7aHR0cDovLzE3Mi4zMS4zMy4zMzo5MTk1O2h0dHA6Ly8xNzIuMzEuMzMu + MzQ6OTE5NjtodHRwOi8vMTcyLjMxLjMzLjM1OjkxOTc7aHR0cDovLzE3Mi4zMS4zMy4zNjo5MTk4 + O2h0dHA6Ly8xNzIuMzEuMzMuMzc6OTE5OUhjb25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzX3By + aXZhdGXAA2h0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MTtodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTI7 + aHR0cDovLzE3Mi4zMS4zMy4zMTo5MTkzO2h0dHA6Ly8xNzIuMzEuMzMuMzI6OTE5NDtodHRwOi8v + MTcyLjMxLjMzLjMzOjkxOTU7aHR0cDovLzE3Mi4zMS4zMy4zNDo5MTk2O2h0dHA6Ly8xNzIuMzEu + MzMuMzU6OTE5NztodHRwOi8vMTcyLjMxLjMzLjM2OjkxOTg7aHR0cDovLzE3Mi4zMS4zMy4zNzo5 + MTk5KHN5c3RlbS5mb250X2ZhbWlsaWVzpgFEZWphVnUgTWF0aCBUZVggR3lyZSxEZWphVnUgU2Fu + cyBNb25vLERlamFWdSBTYW5zLERlamFWdSBTZXJpZixTYW5zLFNlcmlmLE1vbm9zcGFjZTB2ZXJz + aW9uLmdwdWRiX2J1aWxkX2RhdGUoRmViIDE0IDIwMjQgMjM6NDk6MDFAdmVyc2lvbi5ncHVkYl9j + b21wdXRlX2NhcGFiaWxpdHkWNjA7NzA7ODA7ODY4dmVyc2lvbi5ncHVkYl9jb21wdXRlX2VuZ2lu + ZQhDVURBPnZlcnNpb24uZ3B1ZGJfY29yZV9saWJzX3ZlcnNpb24UMjAyNDAyMTMwMDR2ZXJzaW9u + LmdwdWRiX2NvcmVfdmVyc2lvbiw3LjIuMC4xLjIwMjQwMjE0MjEwOTA2NHZlcnNpb24uZ3B1ZGJf + ZmlsZV92ZXJzaW9uFDIwMjEwMzExMjAqdmVyc2lvbi5ncHVkYl92ZXJzaW9uUDkyMjYwYTMyOWNh + NDVjYjBlMzc3NzZjZjkxNDQ5NzE3OWY2MjExNDM0dmVyc2lvbi5ncHVkYl92ZXJzaW9uX2RhdGUy + MjAyNC0wMi0xNCAyMTowOTowNiAtMDUwMCx2ZXJzaW9uLnB5dGhvbl92ZXJzaW9uDjMuMTAuMTMA + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00063' + status: + code: 200 + message: OK +version: 1 diff --git a/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_full_chain.yaml b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_full_chain.yaml new file mode 100644 index 0000000000..5fa7e5ae41 --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_full_chain.yaml @@ -0,0 +1,887 @@ +interactions: +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/status + response: + body: + string: !!binary | + BE9LADZzaG93X3N5c3RlbV9zdGF0dXNfcmVzcG9uc2X8ugEUCmdyYXBovAl7ImNvdW50Ijo4LCJz + dGF0dXMiOlt7InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjAsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzAiLCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjoxLCJob3N0 + X2lkIjoiMTcyLjMxLjMzLjMxIiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNl + cnZlcl9pZCI6MiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMiIsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjMsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzMiLCJzdGF0 + dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo0LCJob3N0X2lkIjoiMTcy + LjMxLjMzLjM0Iiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNlcnZlcl9pZCI6 + NSwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNSIsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24i + OjM5LCJzZXJ2ZXJfaWQiOjYsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzYiLCJzdGF0dXMiOiJydW5u + aW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo3LCJob3N0X2lkIjoiMTcyLjMxLjMzLjM3 + Iiwic3RhdHVzIjoicnVubmluZyJ9XX0eaGFfY2x1c3Rlcl9pbmZvzAN7ImhhX3JhbmtzX2luZm8i + Olt7InByaXZhdGVfdXJsIjoiaHR0cDovLzE3Mi4zMS4zMy4zMDo5MTkxIiwicHVibGljX3VybCI6 + Imh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MSIsImhhX3VybF9vdmVycmlkZSI6Imh0dHA6Ly8xNzIu + MzEuMzMuMzA6OTE5MSIsImFsdGVybmF0ZV91cmxzIjpbImh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5 + MSJdfV0sInJlYWR5Ijp0cnVlLCJuYW1lIjoicHJvZHVjdGlvbi1uZXcifQpob3N0c/hLeyJjb3Vu + dCI6OCwic3RhdHVzIjpbeyJ2ZXJzaW9uIjoxMzMsImhvc3RfbnVtYmVyIjowLCJpZCI6IjE3Mi4z + MS4zMy4zMCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzAtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmci + LCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9z + dGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoicnVubmluZyIsInJldmVh + bF9zdGF0dXMiOiJydW5uaW5nIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEyNjAwMzIsInN0YXJ0X3Rp + bWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4zMCJdLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiLCJHUFUtNTNlMWI3YjQt + NjhiOC1hMjhjLTEwZjMtZGI2YTA1OTdmYmI0IiwiR1BVLTQxZmY5MWZiLWVjYjktMGE1Yi1kNDdj + LWQ1YmI3ZWYxMDM4YSIsIkdQVS1hOTQwYjEyNi1iMWE0LTlmMDctNDRlMS02MzZjMzc5ODllY2Yi + XSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoibGVhZGVyIiwiaG9zdF90 + ZXJtIjowLCJob3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9u + IjoxMTMsImhvc3RfbnVtYmVyIjoxLCJpZCI6IjE3Mi4zMS4zMy4zMSIsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzEtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxl + ZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5 + X3BsYW5uZXJfc3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90 + YWxfbWVtb3J5Ijo4MTAyMDEyMzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtf + aXBzIjpbIjE3Mi4zMS4zMy4zMSJdLCJncHVfaWRzIjpbIkdQVS0xMzJmMWRkYi1hNWY0LTIwZDMt + MTEyMi02ZDM1OTlhZmNmMWQiLCJHUFUtM2JjN2JmY2QtOTVhOS1hNjI2LThlOGYtMzdiOTcxOWFh + OWRkIiwiR1BVLWZlMTBhZDNkLTg4M2QtYTU5MC1kNDA1LWUwYTU2OTNiMGFmMCIsIkdQVS02Yjgy + OTY5OS0wYjRjLTEyZjAtMGMyOC04Y2Y0NmMyNGMxODUiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZh + bHNlIiwiaG9zdF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25f + c3RhdHVzIjoibGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjIs + ImlkIjoiMTcyLjMxLjMzLjMyIiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMi12MTAwIiwic3RhdHVz + IjoicnVubmluZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVu + bmluZyIsIm1sX3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9w + cGVkIiwicmV2ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTIzMTM2 + MCwic3RhcnRfdGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjMyIl0s + ImdwdV9pZHMiOlsiR1BVLTA5MGM0NDMwLWRiYmUtMWUxYS03ZjdmLWExODI3ODNhZDIzMSIsIkdQ + VS1iZTE0YjVjZS1iNDExLTQ4Y2EtYTlmZi01YTA2YzdhNmYzOTgiLCJHUFUtNGIxYTU2ODgtMGU4 + Yy1jYzk0LTgzM2ItYzJmMzllOTk1M2I4IiwiR1BVLTEyZWJhNDYzLTgzMmUtMTA4Yi1lY2IyLTVj + OWFmOGRhNjE2NCJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xs + b3dlciIsImhvc3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3Rl + ZCJ9LHsidmVyc2lvbiI6MTEzLCJob3N0X251bWJlciI6MywiaWQiOiIxNzIuMzEuMzMuMzMiLCJo + b3N0bmFtZSI6IjMwMC0zMDMtdTMzLXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3Rh + dHVzIjoiZGlzYWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlz + YWJsZWQiLCJxdWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoi + c3RvcHBlZCIsInRvdGFsX21lbW9yeSI6ODEwMjAxMjM5NTUyLCJzdGFydF90aW1lIjoxNzA4MTAz + NDUyLCJuZXR3b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzMiXSwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImFjY2VwdHNf + ZmFpbG92ZXIiOiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJo + b3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhv + c3RfbnVtYmVyIjo0LCJpZCI6IjE3Mi4zMS4zMy4zNCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzQt + djEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRz + X3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJf + c3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5 + Ijo4MTAyMDEyMTA4ODAsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3 + Mi4zMS4zMy4zNCJdLCJncHVfaWRzIjpbIkdQVS02OGUwOWNmYy1mOWE0LTJhMTQtNTdhNC05NDgz + YjkxYzJkOWEiLCJHUFUtM2RmMjE2ZTgtZmU3NC0wNDdhLTk1YWMtNzJlMmNiZWNiNTIyIiwiR1BV + LTE0ZDQ0Yjk4LWIwNDItY2I4MS0xZGQzLTIwZDRmNjljODljYSIsIkdQVS0zNDA2NzMwYi1iZWFk + LWM1MGEtNDZlYi1lMGEyYzJiZjZlNzYiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9z + dF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoi + bGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjUsImlkIjoiMTcy + LjMxLjMzLjM1IiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNS12MTAwIiwic3RhdHVzIjoicnVubmlu + ZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVubmluZyIsIm1s + X3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9wcGVkIiwicmV2 + ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTI0Nzc0NCwic3RhcnRf + dGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjM1Il0sImdwdV9pZHMi + OlsiR1BVLWY3MzAyYWJjLTllYWEtMTRjOS1mNDI2LTE2M2RmM2RhOGMyNiIsIkdQVS03N2RkN2Q0 + OC1mOTgwLWZkMDYtNzIyYy0xYzViOTMyMTgyMDMiLCJHUFUtNTUyYjIwYTUtNTdlNi00OTg2LWJl + MmItMmIzNzhmZDRiY2FhIiwiR1BVLTYzMDUzMTYyLTMwN2YtNTVjNS1hOTc0LTU4ZGZlODQzNDJi + MiJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xsb3dlciIsImhv + c3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3RlZCJ9LHsidmVy + c2lvbiI6MTEzLCJob3N0X251bWJlciI6NiwiaWQiOiIxNzIuMzEuMzMuMzYiLCJob3N0bmFtZSI6 + IjMwMC0zMDMtdTM2LXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3RhdHVzIjoiZGlz + YWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlzYWJsZWQiLCJx + dWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoic3RvcHBlZCIs + InRvdGFsX21lbW9yeSI6ODEwMjAxMjIzMTY4LCJzdGFydF90aW1lIjoxNzA4MTAzNDUyLCJuZXR3 + b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzYiXSwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04 + MmYwLTNmZTQtZjFmMmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZk + MDA1N2FiOCIsIkdQVS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUt + YWI3NTRhM2MtNjA4Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImFjY2VwdHNfZmFpbG92ZXIi + OiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJob3N0X2VsZWN0 + aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhvc3RfbnVtYmVy + Ijo3LCJpZCI6IjE3Mi4zMS4zMy4zNyIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzctdjEwMCIsInN0 + YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6 + InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoi + c3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEy + MzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4z + NyJdLCJncHVfaWRzIjpbIkdQVS1lYTE4ZDM4OC1lMmIzLTQyODMtYTZiNS1hMzIzYTQ4NzI1YTki + LCJHUFUtZGNkODRlZmItOTRjYS1iNDk3LThjMTUtN2EzMjY5NDBjMWViIiwiR1BVLTkxNjAxYTVl + LTk3M2YtZDFlNC02ZTFkLWY2NTUyOTRkMzQ2MCIsIkdQVS0wN2ZhNGRiNi05ZTU1LWI2MWYtOTA5 + YS04NWM0ZDFiZWIwODgiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoi + Zm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoibGVhZGVyX2Vs + ZWN0ZWQifV19Fmh0dHBfc2VydmVyoAN7ImNvbm5lY3Rpb25zIjp7ImN1cnJlbnQiOjEsIm1heF9j + b25jdXJyZW50IjoxMTYsInF1ZXVlZCI6MCwibWF4X3F1ZXVlZF9hbGxvd2VkIjo2NTUzNiwidG90 + YWwiOjMyNTkwMiwicmVmdXNlZCI6MCwidGhyZWFkcyI6Mn0sInRocmVhZHMiOnsidXNlZCI6Miwi + Y2FwYWNpdHkiOjUxMiwiYWxsb2NhdGVkIjo4LCJhdmFpbGFibGUiOjUxMCwic3RhY2tfc2l6ZSI6 + MH19FG1pZ3JhdGlvbnMueyJjb3VudCI6MCwic3RhdHVzIjpbXX0KcmFua3PgUnsiY291bnQiOjks + InN0YXR1cyI6W3sidmVyc2lvbiI6MTE4LCJyYW5rIjowLCJyYW5rX2lkIjoiMCA6IDE3Mi4zMS4z + My4zMCA6IDMyNzc0MDYiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmci + LCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQy + MTA5MDYiLCJwaWQiOjMyNzc0MDYsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVf + c3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGlu + Z19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1l + IjoiMzAwLTMwMy11MzAtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzAiLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiXSwiZ3B1X2luZGV4Ijow + LCJncHVfaW5kaWNlcyI6WzBdfSx7InZlcnNpb24iOjEwMiwicmFuayI6MSwicmFua19pZCI6IjEg + OiAxNzIuMzEuMzMuMzAgOiAzMjc4NTYwIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMi + OiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4x + LjIwMjQwMjE0MjEwOTA2IiwicGlkIjozMjc4NTYwLCJzdGFydF90aW1lIjoxNzA4NDQzNjU2LCJz + dGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIsInN0YXJ0X2NvdW50Ijox + LCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNl + LCJob3N0bmFtZSI6IjMwMC0zMDMtdTMwLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMwIiwi + Z3B1X2lkcyI6WyJHUFUtYTA3YzBlNDgtOTQ4YS00MDVjLTQzYjctNzM3NGQyZGRjMDhjIiwiR1BV + LTUzZTFiN2I0LTY4YjgtYTI4Yy0xMGYzLWRiNmEwNTk3ZmJiNCIsIkdQVS00MWZmOTFmYi1lY2I5 + LTBhNWItZDQ3Yy1kNWJiN2VmMTAzOGEiLCJHUFUtYTk0MGIxMjYtYjFhNC05ZjA3LTQ0ZTEtNjM2 + YzM3OTg5ZWNmIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJz + aW9uIjoxMDIsInJhbmsiOjIsInJhbmtfaWQiOiIyIDogMTcyLjMxLjMzLjMxIDogMTU0NDUxOSIs + InJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVz + Ijoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTU0 + NDUxOSwic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIw + IDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5l + d19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMS12 + MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMSIsImdwdV9pZHMiOlsiR1BVLTEzMmYxZGRiLWE1 + ZjQtMjBkMy0xMTIyLTZkMzU5OWFmY2YxZCIsIkdQVS0zYmM3YmZjZC05NWE5LWE2MjYtOGU4Zi0z + N2I5NzE5YWE5ZGQiLCJHUFUtZmUxMGFkM2QtODgzZC1hNTkwLWQ0MDUtZTBhNTY5M2IwYWYwIiwi + R1BVLTZiODI5Njk5LTBiNGMtMTJmMC0wYzI4LThjZjQ2YzI0YzE4NSJdLCJncHVfaW5kZXgiOjAs + ImdwdV9pbmRpY2VzIjpbMCwxLDIsM119LHsidmVyc2lvbiI6MTAwLCJyYW5rIjozLCJyYW5rX2lk + IjoiMyA6IDE3Mi4zMS4zMy4zMiA6IDE0Mjk2ODUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0 + YXR1cyI6InJ1bm5pbmciLCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6Ijcu + Mi4wLjEuMjAyNDAyMTQyMTA5MDYiLCJwaWQiOjE0Mjk2ODUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2 + NTYsInN0YXJ0X3RpbWVfc3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291 + bnQiOjEsImFjY2VwdGluZ19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6 + ZmFsc2UsImhvc3RuYW1lIjoiMzAwLTMwMy11MzItdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzIiLCJncHVfaWRzIjpbIkdQVS0wOTBjNDQzMC1kYmJlLTFlMWEtN2Y3Zi1hMTgyNzgzYWQyMzEi + LCJHUFUtYmUxNGI1Y2UtYjQxMS00OGNhLWE5ZmYtNWEwNmM3YTZmMzk4IiwiR1BVLTRiMWE1Njg4 + LTBlOGMtY2M5NC04MzNiLWMyZjM5ZTk5NTNiOCIsIkdQVS0xMmViYTQ2My04MzJlLTEwOGItZWNi + Mi01YzlhZjhkYTYxNjQiXSwiZ3B1X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7 + InZlcnNpb24iOjExNiwicmFuayI6NCwicmFua19pZCI6IjQgOiAxNzIuMzEuMzMuMzMgOiAxNjA4 + NzYxIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9z + dGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlk + IjoxNjA4NzYxLCJzdGFydF90aW1lIjoxNzA4NDQzNjU1LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBG + ZWIgMjAgMTU6NDA6NTUgMjAyNCIsInN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1 + ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMt + dTMzLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMzIiwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImdwdV9pbmRl + eCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjUsInJh + bmtfaWQiOiI1IDogMTcyLjMxLjMzLjM0IDogMTY2MDEwMiIsInJhbmtfbW9kZSI6InJ1biIsInJh + bmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9u + IjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTY2MDEwMiwic3RhcnRfdGltZSI6MTcw + ODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFy + dF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9v + bmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNC12MTAwIiwiaG9zdF9pZCI6IjE3Mi4z + MS4zMy4zNCIsImdwdV9pZHMiOlsiR1BVLTY4ZTA5Y2ZjLWY5YTQtMmExNC01N2E0LTk0ODNiOTFj + MmQ5YSIsIkdQVS0zZGYyMTZlOC1mZTc0LTA0N2EtOTVhYy03MmUyY2JlY2I1MjIiLCJHUFUtMTRk + NDRiOTgtYjA0Mi1jYjgxLTFkZDMtMjBkNGY2OWM4OWNhIiwiR1BVLTM0MDY3MzBiLWJlYWQtYzUw + YS00NmViLWUwYTJjMmJmNmU3NiJdLCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIs + M119LHsidmVyc2lvbiI6MTAyLCJyYW5rIjo2LCJyYW5rX2lkIjoiNiA6IDE3Mi4zMS4zMy4zNSA6 + IDEzNzk3MTUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmciLCJyZW1v + dmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQyMTA5MDYi + LCJwaWQiOjEzNzk3MTUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVfc3RyIjoi + VHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGluZ19qb2Jz + Ijp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzUtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzUiLCJncHVfaWRzIjpbIkdQVS1m + NzMwMmFiYy05ZWFhLTE0YzktZjQyNi0xNjNkZjNkYThjMjYiLCJHUFUtNzdkZDdkNDgtZjk4MC1m + ZDA2LTcyMmMtMWM1YjkzMjE4MjAzIiwiR1BVLTU1MmIyMGE1LTU3ZTYtNDk4Ni1iZTJiLTJiMzc4 + ZmQ0YmNhYSIsIkdQVS02MzA1MzE2Mi0zMDdmLTU1YzUtYTk3NC01OGRmZTg0MzQyYjIiXSwiZ3B1 + X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7InZlcnNpb24iOjEwMiwicmFuayI6 + NywicmFua19pZCI6IjcgOiAxNzIuMzEuMzMuMzYgOiAxMzc5NTM5IiwicmFua19tb2RlIjoicnVu + IiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3Zl + cnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlkIjoxMzc5NTM5LCJzdGFydF90aW1l + IjoxNzA4NDQzNjU2LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIs + InN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJy + ZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMtdTM2LXYxMDAiLCJob3N0X2lkIjoi + MTcyLjMxLjMzLjM2IiwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04MmYwLTNmZTQtZjFm + MmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZkMDA1N2FiOCIsIkdQ + VS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUtYWI3NTRhM2MtNjA4 + Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlsw + LDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjgsInJhbmtfaWQiOiI4IDogMTcyLjMxLjMz + LjM3IDogMTM5Nzg5MyIsInJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIs + InJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIx + MDkwNiIsInBpZCI6MTM5Nzg5Mywic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9z + dHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5n + X2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUi + OiIzMDAtMzAzLXUzNy12MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNyIsImdwdV9pZHMiOlsi + R1BVLWVhMThkMzg4LWUyYjMtNDI4My1hNmI1LWEzMjNhNDg3MjVhOSIsIkdQVS1kY2Q4NGVmYi05 + NGNhLWI0OTctOGMxNS03YTMyNjk0MGMxZWIiLCJHUFUtOTE2MDFhNWUtOTczZi1kMWU0LTZlMWQt + ZjY1NTI5NGQzNDYwIiwiR1BVLTA3ZmE0ZGI2LTllNTUtYjYxZi05MDlhLTg1YzRkMWJlYjA4OCJd + LCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIsM119XX0Oc3ltYm9scxZ7ImNvdW50 + IjoxfQxzeXN0ZW2qA3siaWQiOiJLaW5ldGljYSAzMDAtMzAzLXUzMC12MTAwIiwic3RhcnRfdGlt + ZSI6MTcwODEwMzQ1Miwic3RhdHVzIjoicnVubmluZyIsImNsdXN0ZXJfbGVhZGVyIjoiMTcyLjMx + LjMzLjMwIiwidmVyc2lvbiI6MjUsImNsdXN0ZXJfb3BlcmF0aW9uX3J1bm5pbmciOiJmYWxzZSIs + ImNsdXN0ZXJfb3BlcmF0aW9uX3N0YXR1cyI6IiIsIm9mZmxpbmVfc3RhdHVzIjoiZmFsc2UifQh0 + ZXh03AV7ImNvdW50Ijo4LCJzdGF0dXMiOlt7InZlcnNpb24iOjMzLCJyYW5rIjoxLCJzdGF0dXMi + OiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6Miwic3RhdHVzIjoicnVubmluZyJ9LHsi + dmVyc2lvbiI6MzMsInJhbmsiOjMsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24iOjMzLCJy + YW5rIjo0LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6NSwic3RhdHVz + IjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzMsInJhbmsiOjYsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjMzLCJyYW5rIjo3LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywi + cmFuayI6OCwic3RhdHVzIjoicnVubmluZyJ9XX0QdHJpZ2dlcnNeeyJ0b3RhbF9jb3VudCI6MCwi + cmFuZ2VfY291bnQiOjAsIm5haV9jb3VudCI6MH0AAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:38 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00065' + status: + code: 200 + message: OK +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/properties + response: + body: + string: !!binary | + BE9LAD5zaG93X3N5c3RlbV9wcm9wZXJ0aWVzX3Jlc3BvbnNlvPUCpAk8Y29uZi5haS5hcGkuY29u + bmVjdGlvbl90aW1lb3V0BDkwHmNvbmYuYWkuYXBpLmtleQAoY29uZi5haS5hcGkucHJvdmlkZXIW + a2luZXRpY2FsbG0eY29uZi5haS5hcGkudXJsSGh0dHA6Ly8xNzIuMzEuMzEuMTM6ODA1MC9zcWwv + c3VnZ2VzdDBjb25mLmFsZXJ0X2Rpc2tfYWJzb2x1dGUANGNvbmYuYWxlcnRfZGlza19wZXJjZW50 + YWdlGDEsIDUsIDEwLCAyMBxjb25mLmFsZXJ0X2V4ZQAsY29uZi5hbGVydF9ob3N0X3N0YXR1cwhU + UlVFOmNvbmYuYWxlcnRfaG9zdF9zdGF0dXNfZmlsdGVyIGZhdGFsX2luaXRfZXJyb3I4Y29uZi5h + bGVydF9tYXhfc3RvcmVkX2FsZXJ0cwYxMDA0Y29uZi5hbGVydF9tZW1vcnlfYWJzb2x1dGUAOGNv + bmYuYWxlcnRfbWVtb3J5X3BlcmNlbnRhZ2UYMSwgNSwgMTAsIDIwNGNvbmYuYWxlcnRfcmFua19j + dWRhX2Vycm9yCFRSVUVEY29uZi5hbGVydF9yYW5rX2ZhbGxiYWNrX2FsbG9jYXRvcghUUlVFLGNv + bmYuYWxlcnRfcmFua19zdGF0dXMIVFJVRTpjb25mLmFsZXJ0X3Jhbmtfc3RhdHVzX2ZpbHRlclhm + YXRhbF9pbml0X2Vycm9yLCBub3RfcmVzcG9uZGluZywgdGVybWluYXRlZB5jb25mLmF1ZGl0X2Jv + ZHkKRkFMU0UeY29uZi5hdWRpdF9kYXRhCkZBTFNFJGNvbmYuYXVkaXRfaGVhZGVycwpGQUxTRT5j + b25mLmF1dG9fY3JlYXRlX2V4dGVybmFsX3VzZXJzCkZBTFNFTGNvbmYuYnVpbGRfbWF0ZXJpYWxp + emVkX3ZpZXdzX29uX3N0YXJ0Em9uX2RlbWFuZDhjb25mLmJ1aWxkX3BrX2luZGV4X29uX3N0YXJ0 + Em9uX2RlbWFuZDhjb25mLmNodW5rX2NvbHVtbl9tYXhfbWVtb3J5EjUxMjAwMDAwMCpjb25mLmNo + dW5rX21heF9tZW1vcnkUODE5MjAwMDAwMB5jb25mLmNodW5rX3NpemUOODAwMDAwMCJjb25mLmNs + dXN0ZXJfbmFtZRxwcm9kdWN0aW9uLW5ld0Bjb25mLmNvbmN1cnJlbnRfa2VybmVsX2V4ZWN1dGlv + bghUUlVFOmNvbmYuZGVmYXVsdF9wcmltYXJ5X2tleV90eXBlDG1lbW9yeSBjb25mLmRlZmF1bHRf + dHRsBDIwLGNvbmYuZGlzYWJsZV9jbGVhcl9hbGwIVFJVRT5jb25mLmVncmVzc19wYXJxdWV0X2Nv + bXByZXNzaW9uDHNuYXBweSRjb25mLmVuYWJsZV9hbGVydHMIVFJVRSJjb25mLmVuYWJsZV9hdWRp + dApGQUxTRTJjb25mLmVuYWJsZV9hdXRob3JpemF0aW9uCFRSVUVGY29uZi5lbmFibGVfZXh0ZXJu + YWxfYXV0aGVudGljYXRpb24KRkFMU0UwY29uZi5lbmFibGVfZ3JhcGhfc2VydmVyCFRSVUUcY29u + Zi5lbmFibGVfaGEKRkFMU0UuY29uZi5lbmFibGVfaHR0cGRfcHJveHkKRkFMU0UcY29uZi5lbmFi + bGVfbWwKRkFMU0U2Y29uZi5lbmFibGVfb3BlbmdsX3JlbmRlcmVyCFRSVUVAY29uZi5lbmFibGVf + b3ZlcmxhcHBlZF9lcXVpX2pvaW4IVFJVRTRjb25mLmVuYWJsZV9wb3N0Z3Jlc19wcm94eQhUUlVF + PmNvbmYuZW5hYmxlX3ByZWRpY2F0ZV9lcXVpX2pvaW4IVFJVRSJjb25mLmVuYWJsZV9wcm9jcwhU + UlVFJGNvbmYuZW5hYmxlX3JldmVhbAhUUlVFMGNvbmYuZW5hYmxlX3N0YXRzX3NlcnZlcghUUlVF + LmNvbmYuZW5hYmxlX3RleHRfc2VhcmNoCFRSVUU8Y29uZi5lbmFibGVfdmVjdG9ydGlsZV9zZXJ2 + aWNlCFRSVUUsY29uZi5lbmFibGVfdnJhbV9jYWNoZQhUUlVFPmNvbmYuZW5hYmxlX3dvcmtlcl9o + dHRwX3NlcnZlcnMIVFJVRTJjb25mLmV2ZW50X3NlcnZlcl9hZGRyZXNzGDE3Mi4zMS4zMy4zMDRj + b25mLmV2ZW50X3NlcnZlcl9pbnRlcm5hbApGQUxTRTpjb25mLmV4dGVybmFsX2ZpbGVzX2RpcmVj + dG9yeSAvbmZzL2RhdGEvcHVibGljFGNvbmYuZ21faXAYMTcyLjMxLjMzLjMwGmNvbmYuZ21fcG9y + dDEINTU1MiBjb25mLmdtX3B1Yl9wb3J0CDU1NTMoY29uZi5ncmFwaC5oZWFkX3BvcnQIODEwMC5j + b25mLmdyYXBoLnNlcnZlcjAuaG9zdApob3N0MC5jb25mLmdyYXBoLnNlcnZlcjAucG9ydAg4MTAx + OGNvbmYuZ3JhcGguc2VydmVyMC5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjEuaG9zdApo + b3N0MS5jb25mLmdyYXBoLnNlcnZlcjEucG9ydAg4MTAyOGNvbmYuZ3JhcGguc2VydmVyMS5yYW1f + bGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjIuaG9zdApob3N0Mi5jb25mLmdyYXBoLnNlcnZlcjIu + cG9ydAg4MTAzOGNvbmYuZ3JhcGguc2VydmVyMi5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZl + cjMuaG9zdApob3N0My5jb25mLmdyYXBoLnNlcnZlcjMucG9ydAg4MTA0OGNvbmYuZ3JhcGguc2Vy + dmVyMy5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjQuaG9zdApob3N0NC5jb25mLmdyYXBo + LnNlcnZlcjQucG9ydAg4MTA1OGNvbmYuZ3JhcGguc2VydmVyNC5yYW1fbGltaXQCMC5jb25mLmdy + YXBoLnNlcnZlcjUuaG9zdApob3N0NS5jb25mLmdyYXBoLnNlcnZlcjUucG9ydAg4MTA2OGNvbmYu + Z3JhcGguc2VydmVyNS5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjYuaG9zdApob3N0Ni5j + b25mLmdyYXBoLnNlcnZlcjYucG9ydAg4MTA3OGNvbmYuZ3JhcGguc2VydmVyNi5yYW1fbGltaXQC + MC5jb25mLmdyYXBoLnNlcnZlcjcuaG9zdApob3N0Ny5jb25mLmdyYXBoLnNlcnZlcjcucG9ydAg4 + MTA4OGNvbmYuZ3JhcGguc2VydmVyNy5yYW1fbGltaXQCMBxjb25mLmhhX3F1ZXVlcwAuY29uZi5o + YV9yaW5nX2hlYWRfbm9kZXMAKGNvbmYuaGVhZF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zMBxjb25m + LmhlYWRfcG9ydAg5MTkxImNvbmYuaG1faHR0cF9wb3J0CDkzMDA2Y29uZi5ob3N0MF9hY2NlcHRz + X2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDBfYWRkcmVzcxgxNzIuMzEuMzMuMzAeY29uZi5ob3N0 + MF9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8v + MTcyLjMxLjMzLjMwOjkzMDAsY29uZi5ob3N0MF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMz + LjMwMmNvbmYuaG9zdDBfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMwLGNvbmYuaG9zdDBfcHVi + bGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMChjb25mLmhvc3QwX3JhbV9saW1pdBg2NTY3Njc3 + OTk5OTk2Y29uZi5ob3N0MV9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDFfYWRkcmVz + cxgxNzIuMzEuMzMuMzEeY29uZi5ob3N0MV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MV9ob3N0X21h + bmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMxOjkzMDAsY29uZi5ob3N0MV9wcml2 + YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMxMmNvbmYuaG9zdDFfcHVibGljX2FkZHJlc3MYMTcy + LjMxLjMzLjMxLGNvbmYuaG9zdDFfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMShjb25m + Lmhvc3QxX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0Ml9hY2NlcHRzX2ZhaWxvdmVy + CkZBTFNFJGNvbmYuaG9zdDJfYWRkcmVzcxgxNzIuMzEuMzMuMzIeY29uZi5ob3N0Ml9ncHVzDjAs + MSwyLDNEY29uZi5ob3N0Ml9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMz + LjMyOjkzMDAsY29uZi5ob3N0Ml9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMyMmNvbmYu + aG9zdDJfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMyLGNvbmYuaG9zdDJfcHVibGljX3VybHMm + aHR0cDovLzE3Mi4zMS4zMy4zMihjb25mLmhvc3QyX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29u + Zi5ob3N0M19hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDNfYWRkcmVzcxgxNzIuMzEu + MzMuMzMeY29uZi5ob3N0M19ncHVzDjAsMSwyLDNEY29uZi5ob3N0M19ob3N0X21hbmFnZXJfcHVi + bGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMzOjkzMDAsY29uZi5ob3N0M19wcml2YXRlX3VybCZo + dHRwOi8vMTcyLjMxLjMzLjMzMmNvbmYuaG9zdDNfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMz + LGNvbmYuaG9zdDNfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMyhjb25mLmhvc3QzX3Jh + bV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NF9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNv + bmYuaG9zdDRfYWRkcmVzcxgxNzIuMzEuMzMuMzQeY29uZi5ob3N0NF9ncHVzDjAsMSwyLDNEY29u + Zi5ob3N0NF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM0OjkzMDAs + Y29uZi5ob3N0NF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM0MmNvbmYuaG9zdDRfcHVi + bGljX2FkZHJlc3MYMTcyLjMxLjMzLjM0LGNvbmYuaG9zdDRfcHVibGljX3VybHMmaHR0cDovLzE3 + Mi4zMS4zMy4zNChjb25mLmhvc3Q0X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NV9h + Y2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDVfYWRkcmVzcxgxNzIuMzEuMzMuMzUeY29u + Zi5ob3N0NV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0NV9ob3N0X21hbmFnZXJfcHVibGljX3VybDBo + dHRwOi8vMTcyLjMxLjMzLjM1OjkzMDAsY29uZi5ob3N0NV9wcml2YXRlX3VybCZodHRwOi8vMTcy + LjMxLjMzLjM1MmNvbmYuaG9zdDVfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM1LGNvbmYuaG9z + dDVfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNShjb25mLmhvc3Q1X3JhbV9saW1pdBg2 + NTY3Njc3OTk5OTk2Y29uZi5ob3N0Nl9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDZf + YWRkcmVzcxgxNzIuMzEuMzMuMzYeY29uZi5ob3N0Nl9ncHVzDjAsMSwyLDNEY29uZi5ob3N0Nl9o + b3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM2OjkzMDAsY29uZi5ob3N0 + Nl9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM2MmNvbmYuaG9zdDZfcHVibGljX2FkZHJl + c3MYMTcyLjMxLjMzLjM2LGNvbmYuaG9zdDZfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4z + Nihjb25mLmhvc3Q2X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0N19hY2NlcHRzX2Zh + aWxvdmVyCkZBTFNFJGNvbmYuaG9zdDdfYWRkcmVzcxgxNzIuMzEuMzMuMzceY29uZi5ob3N0N19n + cHVzDjAsMSwyLDNEY29uZi5ob3N0N19ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcy + LjMxLjMzLjM3OjkzMDAsY29uZi5ob3N0N19wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM3 + MmNvbmYuaG9zdDdfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM3LGNvbmYuaG9zdDdfcHVibGlj + X3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNyhjb25mLmhvc3Q3X3JhbV9saW1pdBg2NTY3Njc3OTk5 + OTkqY29uZi5odHRwZF9wcm94eV9wb3J0CDgwODI0Y29uZi5odHRwZF9wcm94eV91c2VfaHR0cHMK + RkFMU0U4Y29uZi5pbml0X3dpdGhfbm93X2F0X3dvcmtlcgpGQUxTRSpjb25mLmthZmthLmJhdGNo + X3NpemUIMTAwMC5jb25mLmthZmthLnBvbGxfdGltZW91dAIwKGNvbmYua2Fma2Eud2FpdF90aW1l + BDMwLmNvbmYua2VybmVsX29tcF90aHJlYWRzAjQ0Y29uZi5sb2FkX3ZlY3RvcnNfb25fc3RhcnQS + b25fZGVtYW5kHmNvbmYubG9ja19hdWRpdApGQUxTRTZjb25mLm1heF9hdXRvX3ZpZXdfdXBkYXRv + cnMCMzZjb25mLm1heF9jb25jdXJyZW50X2tlcm5lbHMCMDJjb25mLm1heF9nZXRfcmVjb3Jkc19z + aXplCjIwMDAwKmNvbmYubWF4X2hlYXRtYXBfc2l6ZQgzMDcyKmNvbmYubWF4X2h0dHBfdGhyZWFk + cwY1MTI6Y29uZi5tZXRhZGF0YV9zdG9yZV9zeW5jX21vZGUMbm9ybWFsKmNvbmYubWluX2h0dHBf + dGhyZWFkcwI4MGNvbmYubWluX3Bhc3N3b3JkX2xlbmd0aAIwIGNvbmYubWxfYXBpX3BvcnQIOTE4 + N1xjb25mLm5wMS5idWlsZF9tYXRlcmlhbGl6ZWRfdmlld3Nfb25fbWlncmF0aW9uDGFsd2F5c0hj + b25mLm5wMS5idWlsZF9wa19pbmRleF9vbl9taWdyYXRpb24MYWx3YXlzRGNvbmYubnAxLmNyaXRp + Y2FsX3Jlc3RhcnRfYXR0ZW1wdHMCMTpjb25mLm5wMS5lbmFibGVfaGVhZF9mYWlsb3ZlcgpGQUxT + RT5jb25mLm5wMS5lbmFibGVfd29ya2VyX2ZhaWxvdmVyCkZBTFNFSmNvbmYubnAxLmZhaWxvdmVy + X2Rpc3RyaWJ1dGlvbl9wb2xpY3kIZmlsbERjb25mLm5wMS5sb2FkX3ZlY3RvcnNfb25fbWlncmF0 + aW9uDGFsd2F5c0xjb25mLm5wMS5ub25fY3JpdGljYWxfcmVzdGFydF9hdHRlbXB0cwIzPGNvbmYu + bnAxLnJhbmtfcmVzdGFydF9hdHRlbXB0cwIxMmNvbmYubnAxLnJlc3RhcnRfaW50ZXJ2YWwENjA2 + Y29uZi5ucDEuc3RvcmFnZV9hcGlfc2NyaXB0AChjb25mLm51bWJlcl9vZl9ob3N0cwI4KGNvbmYu + bnVtYmVyX29mX3JhbmtzAjk8Y29uZi5vcGVuZ2xfYW50aWFsaWFzaW5nX2xldmVsAjAsY29uZi5w + ZXJzaXN0X2RpcmVjdG9yeTAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8sY29uZi5wZXJzaXN0X3N5 + bmNfdGltZQI1NmNvbmYucG9pbnRfcmVuZGVyX3RocmVzaG9sZAwxMDAwMDBWY29uZi5wb3N0Z3Jl + c19wcm94eS5pZGxlX2Nvbm5lY3Rpb25fdGltZW91dAYzMDBUY29uZi5wb3N0Z3Jlc19wcm94eS5t + YXhfcXVldWVkX2Nvbm5lY3Rpb25zAjE+Y29uZi5wb3N0Z3Jlc19wcm94eS5tYXhfdGhyZWFkcwQ2 + ND5jb25mLnBvc3RncmVzX3Byb3h5Lm1pbl90aHJlYWRzAjIwY29uZi5wb3N0Z3Jlc19wcm94eS5w + b3J0CDU0MzIuY29uZi5wb3N0Z3Jlc19wcm94eS5zc2wIVFJVRRxjb25mLnJhbmswX2dwdQIwKmNv + bmYucmFuazBfaXBfYWRkcmVzcxgxNzIuMzEuMzMuMzAqY29uZi5yYW5rMV9pcF9hZGRyZXNzGDE3 + Mi4zMS4zMy4zMCpjb25mLnJhbmsyX2lwX2FkZHJlc3MYMTcyLjMxLjMzLjMxKmNvbmYucmFuazNf + aXBfYWRkcmVzcxgxNzIuMzEuMzMuMzIqY29uZi5yYW5rNF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4z + Mypjb25mLnJhbms1X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM0KmNvbmYucmFuazZfaXBfYWRkcmVz + cxgxNzIuMzEuMzMuMzUqY29uZi5yYW5rN19pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zNipjb25mLnJh + bms4X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM3KGNvbmYucmVxdWVzdF90aW1lb3V0CDI0MDA2Y29u + Zi5yZXF1aXJlX2F1dGhlbnRpY2F0aW9uCFRSVUVeY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0 + Lm1heF9jcHVfY29uY3VycmVuY3kELTFaY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0Lm1heF90 + aWVyX3ByaW9yaXR5BDEwSmNvbmYucmVzb3VyY2VfZ3JvdXAuZGVmYXVsdC5yYW1fbGltaXQELTFa + Y29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0LnNjaGVkdWxlX3ByaW9yaXR5BDUwTGNvbmYucmVz + b3VyY2VfZ3JvdXAuZGVmYXVsdC52cmFtX2xpbWl0BC0xHGNvbmYucmluZ19uYW1lDmRlZmF1bHRW + Y29uZi5zZWN1cml0eS5leHRlcm5hbC5yYW5nZXIuY2FjaGVfbWludXRlcwQ2MFRjb25mLnNlY3Vy + aXR5LmV4dGVybmFsLnJhbmdlci5zZXJ2aWNlX25hbWUQa2luZXRpY2FCY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXIudXJsAGBjb25mLnNlY3VyaXR5LmV4dGVybmFsLnJhbmdlcl9hdXRob3Jp + emVyLmFkZHJlc3MyaXBjOi8vL3RtcC9ncHVkYi1yYW5nZXItMHRjb25mLnNlY3VyaXR5LmV4dGVy + bmFsLnJhbmdlcl9hdXRob3JpemVyLnJlbW90ZV9kZWJ1Z19wb3J0AjBgY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXJfYXV0aG9yaXplci50aW1lb3V0BjEyMCpjb25mLnNldF9tb25pdG9yX3Bv + cnQIOTAwMjZjb25mLnNldF9tb25pdG9yX3Byb3h5X3BvcnQIOTAwMzZjb25mLnNldF9tb25pdG9y + X3F1ZXVlX3NpemUIMTAwMChjb25mLnNoYWRvd19hZ2dfc2l6ZRI1MDAwMDAwMDAwY29uZi5zaGFk + b3dfY3ViZV9lbmFibGVkCFRSVUUuY29uZi5zaGFkb3dfZmlsdGVyX3NpemUSNTAwMDAwMDAwJmNv + bmYuc21fb21wX3RocmVhZHMCMiRjb25mLnNtc19kaXJlY3RvcnkwL21udC9kYXRhL2dwdWRiL3Bl + cnNpc3QvLmNvbmYuc21zX21heF9vcGVuX2ZpbGVzBjEyOEBjb25mLnNxbC5jb3N0X2Jhc2VkX29w + dGltaXphdGlvbgpGQUxTRTRjb25mLnNxbC5kaXN0cmlidXRlZF9qb2lucwhUUlVFPmNvbmYuc3Fs + LmRpc3RyaWJ1dGVkX29wZXJhdGlvbnMIVFJVRS5jb25mLnNxbC5lbmFibGVfcGxhbm5lcghUUlVF + NmNvbmYuc3FsLmZvcmNlX2JpbmFyeV9qb2lucwpGQUxTRTpjb25mLnNxbC5mb3JjZV9iaW5hcnlf + c2V0X29wcwpGQUxTRTZjb25mLnNxbC5tYXhfcGFyYWxsZWxfc3RlcHMCNEBjb25mLnNxbC5tYXhf + dmlld19uZXN0aW5nX2xldmVscwQxNjJjb25mLnNxbC5wYWdpbmdfdGFibGVfdHRsBDIwNmNvbmYu + c3FsLnBhcmFsbGVsX2V4ZWN1dGlvbghUUlVFMGNvbmYuc3FsLnBsYW5fY2FjaGVfc2l6ZQg0MDAw + MGNvbmYuc3FsLnBsYW5uZXIuYWRkcmVzcz5pcGM6Ly8vdG1wL2dwdWRiLXF1ZXJ5LWVuZ2luZS0w + NmNvbmYuc3FsLnBsYW5uZXIubWF4X21lbW9yeQg0MDk2NGNvbmYuc3FsLnBsYW5uZXIubWF4X3N0 + YWNrAjZEY29uZi5zcWwucGxhbm5lci5yZW1vdGVfZGVidWdfcG9ydAIwMGNvbmYuc3FsLnBsYW5u + ZXIudGltZW91dAYxMjA0Y29uZi5zcWwucmVzdWx0X2NhY2hlX3NpemUINDAwMDRjb25mLnNxbC5y + ZXN1bHRzLmNhY2hlX3R0bAQ2MDBjb25mLnNxbC5yZXN1bHRzLmNhY2hpbmcIVFJVRUBjb25mLnNx + bC5ydWxlX2Jhc2VkX29wdGltaXphdGlvbghUUlVFPGNvbmYuc3VidGFza19jb25jdXJyZW5jeV9s + aW1pdAI0PmNvbmYuc3ltYm9sb2d5X3JlbmRlcl90aHJlc2hvbGQKMTAwMDBQY29uZi5zeXN0ZW1f + bWV0YWRhdGEuc3RhdHNfYWdncl9yb3djb3VudAoxMDAwMEhjb25mLnN5c3RlbV9tZXRhZGF0YS5z + dGF0c19hZ2dyX3RpbWUCMVJjb25mLnN5c3RlbV9tZXRhZGF0YS5zdGF0c19yZXRlbnRpb25fZGF5 + cwQyMSZjb25mLnRhc2tjYWxjX2dwdS4xElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4yElsw + LDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4zElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS40 + ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS41ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dw + dS42ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS43ElswLDEsMiwzXSZjb25mLnRhc2tjYWxj + X2dwdS44ElswLDEsMiwzXSBjb25mLnRjc19wZXJfdG9tBDQwJmNvbmYudGVtcF9kaXJlY3RvcnkI + L3RtcDJjb25mLnRleHRfaW5kZXhfZGlyZWN0b3J5MC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0LzJj + b25mLnRleHRfaW5kaWNlc19wZXJfdG9tAjJMY29uZi50aWVyLmRpc2swLmRlZmF1bHQuaGlnaF93 + YXRlcm1hcmsEOTA6Y29uZi50aWVyLmRpc2swLmRlZmF1bHQubGltaXQYNjAwMDAwMDAwMDAwSmNv + bmYudGllci5kaXNrMC5kZWZhdWx0Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLmRpc2swLmRl + ZmF1bHQucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlYGNvbmYudGllci5k + aXNrMC5kZWZhdWx0LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlz + azAucmFuazAuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbmswLmxpbWl0GDYw + MDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazAubG93X3dhdGVybWFyawQ4MDRjb25mLnRp + ZXIuZGlzazAucmFuazAucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNv + bmYudGllci5kaXNrMC5yYW5rMC5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50 + aWVyLmRpc2swLnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rMS5s + aW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJhbmsxLmxvd193YXRlcm1hcmsEODA0 + Y29uZi50aWVyLmRpc2swLnJhbmsxLnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tj + YWNoZVxjb25mLnRpZXIuZGlzazAucmFuazEuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNF + SGNvbmYudGllci5kaXNrMC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAu + cmFuazIubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rMi5sb3dfd2F0ZXJt + YXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rMi5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0 + Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbmsyLnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0 + cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazMuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVy + LmRpc2swLnJhbmszLmxpbWl0GDYwMDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazMubG93 + X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazMucGF0aEQvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5yYW5rMy5zdG9yZV9wZXJzaXN0ZW50 + X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNv + bmYudGllci5kaXNrMC5yYW5rNC5saW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJh + bms0Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2swLnJhbms0LnBhdGhEL21udC9kYXRh + L2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIuZGlzazAucmFuazQuc3RvcmVfcGVy + c2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNrMC5yYW5rNS5oaWdoX3dhdGVybWFy + awQ5MDZjb25mLnRpZXIuZGlzazAucmFuazUubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5k + aXNrMC5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rNS5wYXRoRC9t + bnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbms1LnN0 + b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazYuaGlnaF93 + YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbms2LmxpbWl0GDYwMDAwMDAwMDAwMEZjb25m + LnRpZXIuZGlzazAucmFuazYubG93X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazYu + cGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5y + YW5rNi5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms3 + LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rNy5saW1pdBg2MDAwMDAwMDAw + MDBGY29uZi50aWVyLmRpc2swLnJhbms3Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2sw + LnJhbms3LnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIu + ZGlzazAucmFuazcuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNr + MC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAucmFuazgubGltaXQYNjAw + MDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGll + ci5kaXNrMC5yYW5rOC5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29u + Zi50aWVyLmRpc2swLnJhbms4LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRVBjb25mLnRp + ZXIuZ2xvYmFsLmNvbmN1cnJlbnRfd2FpdF90aW1lb3V0BjYwMGpjb25mLnRpZXIuZ2xvYmFsLmRl + ZmVyX2NhY2hlX29iamVjdF9ldmljdGlvbnNfdG9fZGlzawhUUlVFUGNvbmYudGllci5wZXJzaXN0 + LmRlZmF1bHQuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnBlcnNpc3QuZGVmYXVsdC5saW1p + dBo2NTAwMDAwMDAwMDAwTmNvbmYudGllci5wZXJzaXN0LmRlZmF1bHQubG93X3dhdGVybWFyawQ4 + MDxjb25mLnRpZXIucGVyc2lzdC5kZWZhdWx0LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3Qv + OmNvbmYudGllci5wZXJzaXN0LmdyYXBoMC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpj + b25mLnRpZXIucGVyc2lzdC5ncmFwaDEucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29u + Zi50aWVyLnBlcnNpc3QuZ3JhcGgyLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYu + dGllci5wZXJzaXN0LmdyYXBoMy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRp + ZXIucGVyc2lzdC5ncmFwaDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29uZi50aWVy + LnBlcnNpc3QuZ3JhcGg1LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYudGllci5w + ZXJzaXN0LmdyYXBoNi5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRpZXIucGVy + c2lzdC5ncmFwaDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNp + c3QucmFuazAuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazAubGltaXQa + NjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwOGNv + bmYudGllci5wZXJzaXN0LnJhbmswLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYu + dGllci5wZXJzaXN0LnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJh + bmsxLmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazEubG93X3dhdGVy + bWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rMS5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJz + aXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIu + cGVyc2lzdC5yYW5rMi5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbmsy + Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazIucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNpc3QucmFuazMuaGlnaF93YXRlcm1hcmsEOTA6 + Y29uZi50aWVyLnBlcnNpc3QucmFuazMubGltaXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVy + c2lzdC5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwOGNvbmYudGllci5wZXJzaXN0LnJhbmszLnBhdGgw + L21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYudGllci5wZXJzaXN0LnJhbms0LmhpZ2hfd2F0 + ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJhbms0LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29u + Zi50aWVyLnBlcnNpc3QucmFuazQubG93X3dhdGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5y + YW5rNC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5r + NS5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIucGVyc2lzdC5yYW5rNS5saW1pdBo2NTAwMDAw + MDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbms1Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVy + LnBlcnNpc3QucmFuazUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBl + cnNpc3QucmFuazYuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazYubGlt + aXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgw + OGNvbmYudGllci5wZXJzaXN0LnJhbms2LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNv + bmYudGllci5wZXJzaXN0LnJhbms3LmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0 + LnJhbms3LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazcubG93X3dh + dGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rNy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9w + ZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRp + ZXIucGVyc2lzdC5yYW5rOC5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJh + bms4Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazgucGF0aDAvbW50L2Rh + dGEvZ3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDEucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDIucGF0aDAvbW50L2RhdGEvZ3B1 + ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDMucGF0aDAvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVy + c2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lz + dC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDYucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84 + Y29uZi50aWVyLnBlcnNpc3QudGV4dDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84Y29u + Zi50aWVyLnBlcnNpc3QudGV4dDgucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9IY29uZi50 + aWVyLnJhbS5kZWZhdWx0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5yYW0uZGVmYXVsdC5s + aW1pdAQtMUZjb25mLnRpZXIucmFtLmRlZmF1bHQubG93X3dhdGVybWFyawQ4MERjb25mLnRpZXIu + cmFtLnJhbmswLmhpZ2hfd2F0ZXJtYXJrBDkwMmNvbmYudGllci5yYW0ucmFuazAubGltaXQWNzcy + NjY4MDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazEuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazIuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazMuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazQuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazUuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazYuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazcuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazguaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rOC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwXGNvbmYudGllci52 + cmFtLmRlZmF1bHQuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBKY29uZi50aWVyLnZyYW0uZGVm + YXVsdC5hbGxfZ3B1cy5saW1pdAQtMVpjb25mLnRpZXIudnJhbS5kZWZhdWx0LmFsbF9ncHVzLmxv + d193YXRlcm1hcmsEODBUY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUwLmhpZ2hfd2F0ZXJtYXJr + BDkwQmNvbmYudGllci52cmFtLmRlZmF1bHQuZ3B1MC5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5k + ZWZhdWx0LmdwdTAubG93X3dhdGVybWFyawQ4MFRjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTEu + aGlnaF93YXRlcm1hcmsEOTBCY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUxLmxpbWl0BC0xUmNv + bmYudGllci52cmFtLmRlZmF1bHQuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwVGNvbmYudGllci52cmFt + LmRlZmF1bHQuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MEJjb25mLnRpZXIudnJhbS5kZWZhdWx0Lmdw + dTIubGltaXQELTFSY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUyLmxvd193YXRlcm1hcmsEODBU + Y29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwQmNvbmYudGllci52 + cmFtLmRlZmF1bHQuZ3B1My5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTMubG93 + X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMC5HUFUwLmhpZ2hfd2F0ZXJtYXJrBDkw + PmNvbmYudGllci52cmFtLnJhbmswLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAu + R1BVMC5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmhpZ2hf + d2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYu + dGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazAuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUwLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rMC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsw + LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbmswLmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazAuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUyLmxvd193YXRl + cm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25m + LnRpZXIudnJhbS5yYW5rMC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTMu + bG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5HUFUwLmhpZ2hfd2F0ZXJtYXJr + BDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFu + azEuR1BVMC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLkdQVTEuaGlnaF93 + YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuR1BVMS5saW1pdAQtMU5jb25mLnRpZXIu + dnJhbS5yYW5rMS5HUFUxLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuR1BV + Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5HUFUyLmxpbWl0BC0xTmNv + bmYudGllci52cmFtLnJhbmsxLkdQVTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5y + YW5rMS5HUFUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTMubGlt + aXQELTFOY29uZi50aWVyLnZyYW0ucmFuazEuR1BVMy5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGll + ci52cmFtLnJhbmsxLmFsbF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJh + bmsxLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGllci52cmFtLnJhbmsxLmFsbF9ncHVzLmxvd193 + YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5j + b25mLnRpZXIudnJhbS5yYW5rMS5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsxLmdw + dTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5ncHUxLmhpZ2hfd2F0ZXJt + YXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0u + cmFuazEuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLmdwdTIuaGln + aF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuZ3B1Mi5saW1pdAQtMU5jb25mLnRp + ZXIudnJhbS5yYW5rMS5ncHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEu + Z3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5ncHUzLmxpbWl0BC0x + TmNvbmYudGllci52cmFtLnJhbmsxLmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJh + bS5yYW5rMi5hbGxfZ3B1cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rMi5h + bGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJhbS5yYW5rMi5hbGxfZ3B1cy5sb3dfd2F0ZXJt + YXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50 + aWVyLnZyYW0ucmFuazIuZ3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUwLmxv + d193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazIuZ3B1MS5oaWdoX3dhdGVybWFyawQ5 + MD5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsy + LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMi5ncHUyLmhpZ2hfd2F0 + ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsyLmdwdTIubGltaXQELTFOY29uZi50aWVyLnZy + YW0ucmFuazIuZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTMu + aGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazIuZ3B1My5saW1pdAQtMU5jb25m + LnRpZXIudnJhbS5yYW5rMi5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFu + azMuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dw + dXMubGltaXQELTFWY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4 + MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52 + cmFtLnJhbmszLmdwdTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1MC5sb3dfd2F0 + ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmszLmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29u + Zi50aWVyLnZyYW0ucmFuazMuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUx + Lmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1Mi5oaWdoX3dhdGVybWFy + awQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJh + bmszLmdwdTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUzLmhpZ2hf + d2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmszLmdwdTMubGltaXQELTFOY29uZi50aWVy + LnZyYW0ucmFuazMuZ3B1My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms0LmFs + bF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxp + bWl0BC0xVmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29u + Zi50aWVyLnZyYW0ucmFuazQuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5y + YW5rNC5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms0LmdwdTAubG93X3dhdGVybWFy + awQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGll + ci52cmFtLnJhbms0LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1MS5sb3df + d2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms0LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+ + Y29uZi50aWVyLnZyYW0ucmFuazQuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNC5n + cHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1My5oaWdoX3dhdGVy + bWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFt + LnJhbms0LmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1 + cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5saW1pdAQt + MVZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGll + ci52cmFtLnJhbms1LmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazUu + Z3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNS5ncHUwLmxvd193YXRlcm1hcmsEODBQ + Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJh + bS5yYW5rNS5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms1LmdwdTEubG93X3dhdGVy + bWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNS5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYu + dGllci52cmFtLnJhbms1LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazUuZ3B1Mi5s + b3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms1LmdwdTMuaGlnaF93YXRlcm1hcmsE + OTA+Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5r + NS5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMuaGln + aF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubGltaXQELTFWY29u + Zi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJh + bS5yYW5rNi5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms2LmdwdTAu + bGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1MC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYu + dGllci52cmFtLnJhbms2LmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFu + azYuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNi5ncHUxLmxvd193YXRlcm1hcmsE + ODBQY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIu + dnJhbS5yYW5rNi5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms2LmdwdTIubG93X3dh + dGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNi5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNv + bmYudGllci52cmFtLnJhbms2LmdwdTMubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1 + My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmhpZ2hfd2F0 + ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGll + ci52cmFtLnJhbms3LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFu + azcuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUwLmxpbWl0 + BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIu + dnJhbS5yYW5rNy5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms3Lmdw + dTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNv + bmYudGllci52cmFtLnJhbms3LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0u + cmFuazcuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUyLmxvd193YXRlcm1h + cmsEODBQY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRp + ZXIudnJhbS5yYW5rNy5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTMubG93 + X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5oaWdoX3dhdGVybWFy + awQ5MEZjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJh + bS5yYW5rOC5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms4Lmdw + dTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazguZ3B1MC5saW1pdAQtMU5j + b25mLnRpZXIudnJhbS5yYW5rOC5ncHUwLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazguZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUxLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbms4LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rOC5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms4 + LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazguZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbms4LmdwdTMuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazguZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUzLmxvd193YXRl + cm1hcmsEODA0Y29uZi50aWVyX3N0cmF0ZWd5LmRlZmF1bHRCVlJBTSAyLCBSQU0gNSwgRElTSzAg + NSwgUEVSU0lTVCA1YGNvbmYudGllcl9zdHJhdGVneS5wcmVkaWNhdGVfZXZhbHVhdGlvbl9pbnRl + cnZhbAQ2MCRjb25mLnRvbXNfcGVyX3JhbmsCMSBjb25mLnRwc19wZXJfdG9tBDQwImNvbmYudHJp + Z2dlcl9wb3J0CDkwMDE+Y29uZi51bmlmaWVkX3NlY3VyaXR5X25hbWVzcGFjZQpGQUxTRTpjb25m + LnVzZV9leHRlcm5hbF90ZXh0X3NlcnZlcghUUlVFHGNvbmYudXNlX2h0dHBzCkZBTFNFLGNvbmYu + dmlkZW9fZGVmYXVsdF90dGwELTEoY29uZi52aWRlb19tYXhfY291bnQELTEyY29uZi52aWRlb190 + ZW1wX2RpcmVjdG9yeSwvdG1wL2dwdWRiLXRlbXAtdmlkZW9zImNvbmYud2FsLmNoZWNrc3VtCFRS + VUUwY29uZi53YWwuZmx1c2hfZnJlcXVlbmN5BDYwMmNvbmYud2FsLm1heF9zZWdtZW50X3NpemUS + NTAwMDAwMDAwLGNvbmYud2FsLnNlZ21lbnRfY291bnQELTEoY29uZi53YWwuc3luY19wb2xpY3kK + Zmx1c2g2Y29uZi53b3JrZXJfaHR0cF9zZXJ2ZXJfaXBz6AExNzIuMzEuMzMuMzA7MTcyLjMxLjMz + LjMwOzE3Mi4zMS4zMy4zMTsxNzIuMzEuMzMuMzI7MTcyLjMxLjMzLjMzOzE3Mi4zMS4zMy4zNDsx + NzIuMzEuMzMuMzU7MTcyLjMxLjMzLjM2OzE3Mi4zMS4zMy4zNzpjb25mLndvcmtlcl9odHRwX3Nl + cnZlcl9wb3J0c1g5MTkxOzkxOTI7OTE5Mzs5MTk0OzkxOTU7OTE5Njs5MTk3OzkxOTg7OTE5OThj + b25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzwANodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTE7aHR0 + cDovLzE3Mi4zMS4zMy4zMDo5MTkyO2h0dHA6Ly8xNzIuMzEuMzMuMzE6OTE5MztodHRwOi8vMTcy + LjMxLjMzLjMyOjkxOTQ7aHR0cDovLzE3Mi4zMS4zMy4zMzo5MTk1O2h0dHA6Ly8xNzIuMzEuMzMu + MzQ6OTE5NjtodHRwOi8vMTcyLjMxLjMzLjM1OjkxOTc7aHR0cDovLzE3Mi4zMS4zMy4zNjo5MTk4 + O2h0dHA6Ly8xNzIuMzEuMzMuMzc6OTE5OUhjb25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzX3By + aXZhdGXAA2h0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MTtodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTI7 + aHR0cDovLzE3Mi4zMS4zMy4zMTo5MTkzO2h0dHA6Ly8xNzIuMzEuMzMuMzI6OTE5NDtodHRwOi8v + MTcyLjMxLjMzLjMzOjkxOTU7aHR0cDovLzE3Mi4zMS4zMy4zNDo5MTk2O2h0dHA6Ly8xNzIuMzEu + MzMuMzU6OTE5NztodHRwOi8vMTcyLjMxLjMzLjM2OjkxOTg7aHR0cDovLzE3Mi4zMS4zMy4zNzo5 + MTk5KHN5c3RlbS5mb250X2ZhbWlsaWVzpgFEZWphVnUgTWF0aCBUZVggR3lyZSxEZWphVnUgU2Fu + cyBNb25vLERlamFWdSBTYW5zLERlamFWdSBTZXJpZixTYW5zLFNlcmlmLE1vbm9zcGFjZTB2ZXJz + aW9uLmdwdWRiX2J1aWxkX2RhdGUoRmViIDE0IDIwMjQgMjM6NDk6MDFAdmVyc2lvbi5ncHVkYl9j + b21wdXRlX2NhcGFiaWxpdHkWNjA7NzA7ODA7ODY4dmVyc2lvbi5ncHVkYl9jb21wdXRlX2VuZ2lu + ZQhDVURBPnZlcnNpb24uZ3B1ZGJfY29yZV9saWJzX3ZlcnNpb24UMjAyNDAyMTMwMDR2ZXJzaW9u + LmdwdWRiX2NvcmVfdmVyc2lvbiw3LjIuMC4xLjIwMjQwMjE0MjEwOTA2NHZlcnNpb24uZ3B1ZGJf + ZmlsZV92ZXJzaW9uFDIwMjEwMzExMjAqdmVyc2lvbi5ncHVkYl92ZXJzaW9uUDkyMjYwYTMyOWNh + NDVjYjBlMzc3NzZjZjkxNDQ5NzE3OWY2MjExNDM0dmVyc2lvbi5ncHVkYl92ZXJzaW9uX2RhdGUy + MjAyNC0wMi0xNCAyMTowOTowNiAtMDUwMCx2ZXJzaW9uLnB5dGhvbl92ZXJzaW9uDjMuMTAuMTMA + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:38 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00095' + status: + code: 200 + message: OK +- request: + body: !!binary | + hAFHRU5FUkFURSBQUk9NUFQgV0lUSCBPUFRJT05TIChDT05URVhUX05BTUVTID0gJ2RlbW8udGVz + dF9sbG1fY3R4JykAAgxiaW5hcnkAAAA= + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/execute/sql + response: + body: + string: !!binary | + BE9LAChleGVjdXRlX3NxbF9yZXNwb25zZe4MAPYDeyJuYW1lIjoiZ2VuZXJpY19yZXNwb25zZSIs + InR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJjb2x1bW5fMSIsInR5cGUiOnsidHlw + ZSI6ImFycmF5IiwiaXRlbXMiOiJzdHJpbmcifX0seyJuYW1lIjoiY29sdW1uX2hlYWRlcnMiLCJ0 + eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19LHsibmFtZSI6ImNvbHVtbl9k + YXRhdHlwZXMiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19XX2qBwL+ + BnsicGF5bG9hZCI6eyJjb250ZXh0IjpbeyJ0YWJsZSI6ImRlbW8udGVzdF9wcm9maWxlcyIsImNv + bHVtbnMiOlsidXNlcm5hbWUgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwibmFtZSBWQVJDSEFSICgz + MikgTk9UIE5VTEwiLCJzZXggVkFSQ0hBUiAoMSkgTk9UIE5VTEwiLCJhZGRyZXNzIFZBUkNIQVIg + KDY0KSBOT1QgTlVMTCIsIm1haWwgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwiYmlydGhkYXRlIFRJ + TUVTVEFNUCBOT1QgTlVMTCJdLCJkZXNjcmlwdGlvbiI6IkNvbnRhaW5zIHVzZXIgcHJvZmlsZXMu + IiwicnVsZXMiOltdfSx7InNhbXBsZXMiOnsiSG93IG1hbnkgbWFsZSB1c2VycyBhcmUgdGhlcmU/ + Ijoic2VsZWN0IGNvdW50KDEpIGFzIG51bV91c2Vyc1xuICAgICAgICAgICAgZnJvbSBkZW1vLnRl + c3RfcHJvZmlsZXNcbiAgICAgICAgICAgIHdoZXJlIHNleCA9ICcnTScnOyJ9fV19fQACDFByb21w + dAACDHN0cmluZwAAAgAACCBYLUtpbmV0aWNhLUdyb3VwBkRETApjb3VudAIwGmxhc3RfZW5kcG9p + bnQsL2dlbmVyYXRlL3NxbC9pbnRlcm5hbC50b3RhbF9udW1iZXJfb2ZfcmVjb3JkcwIwAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:38 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Kinetica-Group: + - DDL + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00685' + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "CREATE TABLE demo.test_profiles + AS\n(\n username VARCHAR (32) NOT NULL,\n name VARCHAR (32) NOT NULL,\n sex + VARCHAR (1) NOT NULL,\n address VARCHAR (64) NOT NULL,\n mail VARCHAR (32) + NOT NULL,\n birthdate TIMESTAMP NOT NULL\n);\nCOMMENT ON TABLE demo.test_profiles + IS ''Contains user profiles.'';"}, {"role": "user", "content": "How many male + users are there?"}, {"role": "assistant", "content": "select count(1) as num_users\n from + demo.test_profiles\n where sex = ''M'';"}, {"role": "user", "content": + "What are the female users ordered by username?"}]}' + headers: + Accept: + - text/plain + Content-type: + - application/json + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/chat/completions + response: + body: + string: '{"status":"OK","data":{"status":"OK","data":{"id":"chatCompl-1708561599","object":"chat.completion","created":1708561600,"model":"sqlassist-1.1","choices":[{"index":0,"message":{"role":"assistant","content":"SELECT + username, name\n FROM demo.test_profiles\n WHERE sex + = ''F''\n ORDER BY username;"},"finish_reason":"stop"}],"usage":{"prompt_tokens":140,"completion_tokens":22,"total_tokens":162},"prompt":"What + are the female users ordered by username?"}}}' + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/json + Date: + - Thu, 22 Feb 2024 00:26:39 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.89590' + status: + code: 200 + message: OK +- request: + body: !!binary | + 6AFTRUxFQ1QgdXNlcm5hbWUsIG5hbWUKICAgICAgICAgICAgRlJPTSBkZW1vLnRlc3RfcHJvZmls + ZXMKICAgICAgICAgICAgV0hFUkUgc2V4ID0gJ0YnCiAgICAgICAgICAgIE9SREVSIEJZIHVzZXJu + YW1lOwCQTgxiaW5hcnkAAAIYcGFnaW5nX3RhYmxlSGJiYWMyMGQ4XzI2ZThfNDI1Zl9iY2ZhX2Ez + MDczNzZmMzhmMAA= + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/execute/sql + response: + body: + string: !!binary | + BE9LAChleGVjdXRlX3NxbF9yZXNwb25zZZ4YAPAEeyJuYW1lIjoiZ2VuZXJpY19yZXNwb25zZSIs + InR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJjb2x1bW5fMSIsInR5cGUiOnsidHlw + ZSI6ImFycmF5IiwiaXRlbXMiOiJzdHJpbmcifX0seyJuYW1lIjoiY29sdW1uXzIiLCJ0eXBlIjp7 + InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19LHsibmFtZSI6ImNvbHVtbl9oZWFkZXJz + IiwidHlwZSI6eyJ0eXBlIjoiYXJyYXkiLCJpdGVtcyI6InN0cmluZyJ9fSx7Im5hbWUiOiJjb2x1 + bW5fZGF0YXR5cGVzIiwidHlwZSI6eyJ0eXBlIjoiYXJyYXkiLCJpdGVtcyI6InN0cmluZyJ9fV19 + 2hFYFmFsZXhhbmRlcjQwDmJidXJ0b24OYnJpYW4xMhJicm93bmFubmEMY2FybDE5HmNhc3RpbGxv + Y2FtZXJvbhpjaHJpc3RvcGhlcjI0GGNsYXJrbWF0dGhldx5jb2xsaW5zbWljaGVsbGUWZGF2aWRn + cmltZXMMZG1vcmFuEmVkdWFyZG82ORRlcmljZGVubmlzGmVyaWthcmV5bm9sZHMYZmxveWRjeW50 + aGlhFmdyYW50aG9ydG9uGGhlbnJ5Y29sbGlucxpoaWdnaW5zcm9iZXJ0GGphY3F1ZWxpbmUyNw5q + YW1lczI2DGpzaG9ydBRraW1iZXJseTY2HGtyaXN0aW5iYXJuZXR0EmxhbmVqYWNvYg5sYXVyYTI4 + GGxhdXJhbWF5bmFyZBBsZWR3YXJkcwxsaGVucnkSbWVsaXNzYTQ5Gm1lbGlzc2FidXRsZXIWbW9v + cmVhbmRyZXcQbmF0aGFuNjMabmljb2xlYmFsZHdpbg5xd3JpZ2h0DnJhbHBoMjUMc21ja2VlEnN1 + c2Fucm9zZQ50cmFjeTUzGnZpY3RvcmlhbW9vcmUYd2FsdGVyc2RhdmlkDndhbmRhOTkSd2lsbGlh + bTU3HHdpbGxpYW1uaWNob2xzDnltb2xpbmEAWBhUaW5hIFJhbWlyZXoYUGF1bGEgS2Fpc2VyIlN0 + ZWZhbmllIFdpbGxpYW1zGkplbm5pZmVyIFJvd2UYQW1hbmRhIFBvdHRzGkJyb29rZSBIYXJtb24W + S2VsbHkgV2F0dHMaSnVsaWUgQ29sbGlucyBIZWF0aGVyIENhbGxhaGFuFEphbmV0IExhcmEeQXNo + bGV5IEpvaG5zdG9uFEhhbGV5IEJlY2seSGVhdGhlciBKYWNrc29uHENhcnJpZSBTaGVsdG9uFEp1 + ZHkgT3J0aXoaTWVsaXNzYSBEaXhvbhxEYXJsZW5lIE11cnJheRpNYXJ5IFJpY2hhcmRzEk1hcnkg + U290bx5QYXRyaWNpYSBQb3R0ZXIaQmVja3kgSm9obnNvbhZNYXJpYSBXb29kcx5EZWJvcmFoIFdh + bGxhY2UaQ2hlbHNlYSBXZWVrcxhEb25uYSBNYWRkZW4WRW1pbHkgQWxsZW4mTXJzLiBKdWxpZSBC + cmFkc2hhdxhFcmluIEJhcmFqYXMWV2VuZHkgUmVlc2UWQWxleGEgS2VsbHkaV2VuZHkgUmFtaXJl + ehhTdGFjZXkgSGFyZHkaQW5nZWxhIEhvcnRvbhxLZWxseSBGcmFua2xpbhhMYXVyYSBOZWxzb24Y + RXJpY2EgUm9tZXJvGE1hcmlhIFBhcmtlchpDaGVsc2VhIFNpbmdoHkNocmlzdHkgSm9obnNvbiRT + YW1hbnRoYSBMZXdpcyBERFMeSmVzc2ljYSBIZXJyZXJhHkVsaXphYmV0aCBXZWxscxZMYXVyYSBT + dG9uZRxBbmdlbGEgU3VtbWVycwAEEHVzZXJuYW1lCG5hbWUABAxjaGFyMzIMY2hhcjMyAABYAAAI + IFgtS2luZXRpY2EtR3JvdXAKUVVFUlkKY291bnQENDQabGFzdF9lbmRwb2ludCovZ2V0L3JlY29y + ZHMvYnljb2x1bW4udG90YWxfbnVtYmVyX29mX3JlY29yZHMENDQAAA== + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:40 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Kinetica-Group: + - QUERY + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.04596' + status: + code: 200 + message: OK +version: 1 diff --git a/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_generate.yaml b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_generate.yaml new file mode 100644 index 0000000000..448ef7b7dd --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_generate.yaml @@ -0,0 +1,815 @@ +interactions: +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/status + response: + body: + string: !!binary | + BE9LADZzaG93X3N5c3RlbV9zdGF0dXNfcmVzcG9uc2X8ugEUCmdyYXBovAl7ImNvdW50Ijo4LCJz + dGF0dXMiOlt7InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjAsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzAiLCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjoxLCJob3N0 + X2lkIjoiMTcyLjMxLjMzLjMxIiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNl + cnZlcl9pZCI6MiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMiIsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjMsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzMiLCJzdGF0 + dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo0LCJob3N0X2lkIjoiMTcy + LjMxLjMzLjM0Iiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNlcnZlcl9pZCI6 + NSwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNSIsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24i + OjM5LCJzZXJ2ZXJfaWQiOjYsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzYiLCJzdGF0dXMiOiJydW5u + aW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo3LCJob3N0X2lkIjoiMTcyLjMxLjMzLjM3 + Iiwic3RhdHVzIjoicnVubmluZyJ9XX0eaGFfY2x1c3Rlcl9pbmZvzAN7ImhhX3JhbmtzX2luZm8i + Olt7InByaXZhdGVfdXJsIjoiaHR0cDovLzE3Mi4zMS4zMy4zMDo5MTkxIiwicHVibGljX3VybCI6 + Imh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MSIsImhhX3VybF9vdmVycmlkZSI6Imh0dHA6Ly8xNzIu + MzEuMzMuMzA6OTE5MSIsImFsdGVybmF0ZV91cmxzIjpbImh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5 + MSJdfV0sInJlYWR5Ijp0cnVlLCJuYW1lIjoicHJvZHVjdGlvbi1uZXcifQpob3N0c/hLeyJjb3Vu + dCI6OCwic3RhdHVzIjpbeyJ2ZXJzaW9uIjoxMzMsImhvc3RfbnVtYmVyIjowLCJpZCI6IjE3Mi4z + MS4zMy4zMCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzAtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmci + LCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9z + dGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoicnVubmluZyIsInJldmVh + bF9zdGF0dXMiOiJydW5uaW5nIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEyNjAwMzIsInN0YXJ0X3Rp + bWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4zMCJdLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiLCJHUFUtNTNlMWI3YjQt + NjhiOC1hMjhjLTEwZjMtZGI2YTA1OTdmYmI0IiwiR1BVLTQxZmY5MWZiLWVjYjktMGE1Yi1kNDdj + LWQ1YmI3ZWYxMDM4YSIsIkdQVS1hOTQwYjEyNi1iMWE0LTlmMDctNDRlMS02MzZjMzc5ODllY2Yi + XSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoibGVhZGVyIiwiaG9zdF90 + ZXJtIjowLCJob3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9u + IjoxMTMsImhvc3RfbnVtYmVyIjoxLCJpZCI6IjE3Mi4zMS4zMy4zMSIsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzEtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxl + ZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5 + X3BsYW5uZXJfc3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90 + YWxfbWVtb3J5Ijo4MTAyMDEyMzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtf + aXBzIjpbIjE3Mi4zMS4zMy4zMSJdLCJncHVfaWRzIjpbIkdQVS0xMzJmMWRkYi1hNWY0LTIwZDMt + MTEyMi02ZDM1OTlhZmNmMWQiLCJHUFUtM2JjN2JmY2QtOTVhOS1hNjI2LThlOGYtMzdiOTcxOWFh + OWRkIiwiR1BVLWZlMTBhZDNkLTg4M2QtYTU5MC1kNDA1LWUwYTU2OTNiMGFmMCIsIkdQVS02Yjgy + OTY5OS0wYjRjLTEyZjAtMGMyOC04Y2Y0NmMyNGMxODUiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZh + bHNlIiwiaG9zdF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25f + c3RhdHVzIjoibGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjIs + ImlkIjoiMTcyLjMxLjMzLjMyIiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMi12MTAwIiwic3RhdHVz + IjoicnVubmluZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVu + bmluZyIsIm1sX3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9w + cGVkIiwicmV2ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTIzMTM2 + MCwic3RhcnRfdGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjMyIl0s + ImdwdV9pZHMiOlsiR1BVLTA5MGM0NDMwLWRiYmUtMWUxYS03ZjdmLWExODI3ODNhZDIzMSIsIkdQ + VS1iZTE0YjVjZS1iNDExLTQ4Y2EtYTlmZi01YTA2YzdhNmYzOTgiLCJHUFUtNGIxYTU2ODgtMGU4 + Yy1jYzk0LTgzM2ItYzJmMzllOTk1M2I4IiwiR1BVLTEyZWJhNDYzLTgzMmUtMTA4Yi1lY2IyLTVj + OWFmOGRhNjE2NCJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xs + b3dlciIsImhvc3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3Rl + ZCJ9LHsidmVyc2lvbiI6MTEzLCJob3N0X251bWJlciI6MywiaWQiOiIxNzIuMzEuMzMuMzMiLCJo + b3N0bmFtZSI6IjMwMC0zMDMtdTMzLXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3Rh + dHVzIjoiZGlzYWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlz + YWJsZWQiLCJxdWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoi + c3RvcHBlZCIsInRvdGFsX21lbW9yeSI6ODEwMjAxMjM5NTUyLCJzdGFydF90aW1lIjoxNzA4MTAz + NDUyLCJuZXR3b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzMiXSwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImFjY2VwdHNf + ZmFpbG92ZXIiOiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJo + b3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhv + c3RfbnVtYmVyIjo0LCJpZCI6IjE3Mi4zMS4zMy4zNCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzQt + djEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRz + X3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJf + c3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5 + Ijo4MTAyMDEyMTA4ODAsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3 + Mi4zMS4zMy4zNCJdLCJncHVfaWRzIjpbIkdQVS02OGUwOWNmYy1mOWE0LTJhMTQtNTdhNC05NDgz + YjkxYzJkOWEiLCJHUFUtM2RmMjE2ZTgtZmU3NC0wNDdhLTk1YWMtNzJlMmNiZWNiNTIyIiwiR1BV + LTE0ZDQ0Yjk4LWIwNDItY2I4MS0xZGQzLTIwZDRmNjljODljYSIsIkdQVS0zNDA2NzMwYi1iZWFk + LWM1MGEtNDZlYi1lMGEyYzJiZjZlNzYiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9z + dF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoi + bGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjUsImlkIjoiMTcy + LjMxLjMzLjM1IiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNS12MTAwIiwic3RhdHVzIjoicnVubmlu + ZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVubmluZyIsIm1s + X3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9wcGVkIiwicmV2 + ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTI0Nzc0NCwic3RhcnRf + dGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjM1Il0sImdwdV9pZHMi + OlsiR1BVLWY3MzAyYWJjLTllYWEtMTRjOS1mNDI2LTE2M2RmM2RhOGMyNiIsIkdQVS03N2RkN2Q0 + OC1mOTgwLWZkMDYtNzIyYy0xYzViOTMyMTgyMDMiLCJHUFUtNTUyYjIwYTUtNTdlNi00OTg2LWJl + MmItMmIzNzhmZDRiY2FhIiwiR1BVLTYzMDUzMTYyLTMwN2YtNTVjNS1hOTc0LTU4ZGZlODQzNDJi + MiJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xsb3dlciIsImhv + c3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3RlZCJ9LHsidmVy + c2lvbiI6MTEzLCJob3N0X251bWJlciI6NiwiaWQiOiIxNzIuMzEuMzMuMzYiLCJob3N0bmFtZSI6 + IjMwMC0zMDMtdTM2LXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3RhdHVzIjoiZGlz + YWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlzYWJsZWQiLCJx + dWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoic3RvcHBlZCIs + InRvdGFsX21lbW9yeSI6ODEwMjAxMjIzMTY4LCJzdGFydF90aW1lIjoxNzA4MTAzNDUyLCJuZXR3 + b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzYiXSwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04 + MmYwLTNmZTQtZjFmMmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZk + MDA1N2FiOCIsIkdQVS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUt + YWI3NTRhM2MtNjA4Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImFjY2VwdHNfZmFpbG92ZXIi + OiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJob3N0X2VsZWN0 + aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhvc3RfbnVtYmVy + Ijo3LCJpZCI6IjE3Mi4zMS4zMy4zNyIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzctdjEwMCIsInN0 + YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6 + InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoi + c3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEy + MzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4z + NyJdLCJncHVfaWRzIjpbIkdQVS1lYTE4ZDM4OC1lMmIzLTQyODMtYTZiNS1hMzIzYTQ4NzI1YTki + LCJHUFUtZGNkODRlZmItOTRjYS1iNDk3LThjMTUtN2EzMjY5NDBjMWViIiwiR1BVLTkxNjAxYTVl + LTk3M2YtZDFlNC02ZTFkLWY2NTUyOTRkMzQ2MCIsIkdQVS0wN2ZhNGRiNi05ZTU1LWI2MWYtOTA5 + YS04NWM0ZDFiZWIwODgiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoi + Zm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoibGVhZGVyX2Vs + ZWN0ZWQifV19Fmh0dHBfc2VydmVyoAN7ImNvbm5lY3Rpb25zIjp7ImN1cnJlbnQiOjEsIm1heF9j + b25jdXJyZW50IjoxMTYsInF1ZXVlZCI6MCwibWF4X3F1ZXVlZF9hbGxvd2VkIjo2NTUzNiwidG90 + YWwiOjMyNTg5OCwicmVmdXNlZCI6MCwidGhyZWFkcyI6Mn0sInRocmVhZHMiOnsidXNlZCI6Miwi + Y2FwYWNpdHkiOjUxMiwiYWxsb2NhdGVkIjo4LCJhdmFpbGFibGUiOjUxMCwic3RhY2tfc2l6ZSI6 + MH19FG1pZ3JhdGlvbnMueyJjb3VudCI6MCwic3RhdHVzIjpbXX0KcmFua3PgUnsiY291bnQiOjks + InN0YXR1cyI6W3sidmVyc2lvbiI6MTE4LCJyYW5rIjowLCJyYW5rX2lkIjoiMCA6IDE3Mi4zMS4z + My4zMCA6IDMyNzc0MDYiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmci + LCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQy + MTA5MDYiLCJwaWQiOjMyNzc0MDYsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVf + c3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGlu + Z19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1l + IjoiMzAwLTMwMy11MzAtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzAiLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiXSwiZ3B1X2luZGV4Ijow + LCJncHVfaW5kaWNlcyI6WzBdfSx7InZlcnNpb24iOjEwMiwicmFuayI6MSwicmFua19pZCI6IjEg + OiAxNzIuMzEuMzMuMzAgOiAzMjc4NTYwIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMi + OiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4x + LjIwMjQwMjE0MjEwOTA2IiwicGlkIjozMjc4NTYwLCJzdGFydF90aW1lIjoxNzA4NDQzNjU2LCJz + dGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIsInN0YXJ0X2NvdW50Ijox + LCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNl + LCJob3N0bmFtZSI6IjMwMC0zMDMtdTMwLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMwIiwi + Z3B1X2lkcyI6WyJHUFUtYTA3YzBlNDgtOTQ4YS00MDVjLTQzYjctNzM3NGQyZGRjMDhjIiwiR1BV + LTUzZTFiN2I0LTY4YjgtYTI4Yy0xMGYzLWRiNmEwNTk3ZmJiNCIsIkdQVS00MWZmOTFmYi1lY2I5 + LTBhNWItZDQ3Yy1kNWJiN2VmMTAzOGEiLCJHUFUtYTk0MGIxMjYtYjFhNC05ZjA3LTQ0ZTEtNjM2 + YzM3OTg5ZWNmIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJz + aW9uIjoxMDIsInJhbmsiOjIsInJhbmtfaWQiOiIyIDogMTcyLjMxLjMzLjMxIDogMTU0NDUxOSIs + InJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVz + Ijoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTU0 + NDUxOSwic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIw + IDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5l + d19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMS12 + MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMSIsImdwdV9pZHMiOlsiR1BVLTEzMmYxZGRiLWE1 + ZjQtMjBkMy0xMTIyLTZkMzU5OWFmY2YxZCIsIkdQVS0zYmM3YmZjZC05NWE5LWE2MjYtOGU4Zi0z + N2I5NzE5YWE5ZGQiLCJHUFUtZmUxMGFkM2QtODgzZC1hNTkwLWQ0MDUtZTBhNTY5M2IwYWYwIiwi + R1BVLTZiODI5Njk5LTBiNGMtMTJmMC0wYzI4LThjZjQ2YzI0YzE4NSJdLCJncHVfaW5kZXgiOjAs + ImdwdV9pbmRpY2VzIjpbMCwxLDIsM119LHsidmVyc2lvbiI6MTAwLCJyYW5rIjozLCJyYW5rX2lk + IjoiMyA6IDE3Mi4zMS4zMy4zMiA6IDE0Mjk2ODUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0 + YXR1cyI6InJ1bm5pbmciLCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6Ijcu + Mi4wLjEuMjAyNDAyMTQyMTA5MDYiLCJwaWQiOjE0Mjk2ODUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2 + NTYsInN0YXJ0X3RpbWVfc3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291 + bnQiOjEsImFjY2VwdGluZ19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6 + ZmFsc2UsImhvc3RuYW1lIjoiMzAwLTMwMy11MzItdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzIiLCJncHVfaWRzIjpbIkdQVS0wOTBjNDQzMC1kYmJlLTFlMWEtN2Y3Zi1hMTgyNzgzYWQyMzEi + LCJHUFUtYmUxNGI1Y2UtYjQxMS00OGNhLWE5ZmYtNWEwNmM3YTZmMzk4IiwiR1BVLTRiMWE1Njg4 + LTBlOGMtY2M5NC04MzNiLWMyZjM5ZTk5NTNiOCIsIkdQVS0xMmViYTQ2My04MzJlLTEwOGItZWNi + Mi01YzlhZjhkYTYxNjQiXSwiZ3B1X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7 + InZlcnNpb24iOjExNiwicmFuayI6NCwicmFua19pZCI6IjQgOiAxNzIuMzEuMzMuMzMgOiAxNjA4 + NzYxIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9z + dGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlk + IjoxNjA4NzYxLCJzdGFydF90aW1lIjoxNzA4NDQzNjU1LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBG + ZWIgMjAgMTU6NDA6NTUgMjAyNCIsInN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1 + ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMt + dTMzLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMzIiwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImdwdV9pbmRl + eCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjUsInJh + bmtfaWQiOiI1IDogMTcyLjMxLjMzLjM0IDogMTY2MDEwMiIsInJhbmtfbW9kZSI6InJ1biIsInJh + bmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9u + IjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTY2MDEwMiwic3RhcnRfdGltZSI6MTcw + ODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFy + dF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9v + bmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNC12MTAwIiwiaG9zdF9pZCI6IjE3Mi4z + MS4zMy4zNCIsImdwdV9pZHMiOlsiR1BVLTY4ZTA5Y2ZjLWY5YTQtMmExNC01N2E0LTk0ODNiOTFj + MmQ5YSIsIkdQVS0zZGYyMTZlOC1mZTc0LTA0N2EtOTVhYy03MmUyY2JlY2I1MjIiLCJHUFUtMTRk + NDRiOTgtYjA0Mi1jYjgxLTFkZDMtMjBkNGY2OWM4OWNhIiwiR1BVLTM0MDY3MzBiLWJlYWQtYzUw + YS00NmViLWUwYTJjMmJmNmU3NiJdLCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIs + M119LHsidmVyc2lvbiI6MTAyLCJyYW5rIjo2LCJyYW5rX2lkIjoiNiA6IDE3Mi4zMS4zMy4zNSA6 + IDEzNzk3MTUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmciLCJyZW1v + dmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQyMTA5MDYi + LCJwaWQiOjEzNzk3MTUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVfc3RyIjoi + VHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGluZ19qb2Jz + Ijp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzUtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzUiLCJncHVfaWRzIjpbIkdQVS1m + NzMwMmFiYy05ZWFhLTE0YzktZjQyNi0xNjNkZjNkYThjMjYiLCJHUFUtNzdkZDdkNDgtZjk4MC1m + ZDA2LTcyMmMtMWM1YjkzMjE4MjAzIiwiR1BVLTU1MmIyMGE1LTU3ZTYtNDk4Ni1iZTJiLTJiMzc4 + ZmQ0YmNhYSIsIkdQVS02MzA1MzE2Mi0zMDdmLTU1YzUtYTk3NC01OGRmZTg0MzQyYjIiXSwiZ3B1 + X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7InZlcnNpb24iOjEwMiwicmFuayI6 + NywicmFua19pZCI6IjcgOiAxNzIuMzEuMzMuMzYgOiAxMzc5NTM5IiwicmFua19tb2RlIjoicnVu + IiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3Zl + cnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlkIjoxMzc5NTM5LCJzdGFydF90aW1l + IjoxNzA4NDQzNjU2LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIs + InN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJy + ZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMtdTM2LXYxMDAiLCJob3N0X2lkIjoi + MTcyLjMxLjMzLjM2IiwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04MmYwLTNmZTQtZjFm + MmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZkMDA1N2FiOCIsIkdQ + VS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUtYWI3NTRhM2MtNjA4 + Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlsw + LDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjgsInJhbmtfaWQiOiI4IDogMTcyLjMxLjMz + LjM3IDogMTM5Nzg5MyIsInJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIs + InJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIx + MDkwNiIsInBpZCI6MTM5Nzg5Mywic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9z + dHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5n + X2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUi + OiIzMDAtMzAzLXUzNy12MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNyIsImdwdV9pZHMiOlsi + R1BVLWVhMThkMzg4LWUyYjMtNDI4My1hNmI1LWEzMjNhNDg3MjVhOSIsIkdQVS1kY2Q4NGVmYi05 + NGNhLWI0OTctOGMxNS03YTMyNjk0MGMxZWIiLCJHUFUtOTE2MDFhNWUtOTczZi1kMWU0LTZlMWQt + ZjY1NTI5NGQzNDYwIiwiR1BVLTA3ZmE0ZGI2LTllNTUtYjYxZi05MDlhLTg1YzRkMWJlYjA4OCJd + LCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIsM119XX0Oc3ltYm9scxZ7ImNvdW50 + IjoxfQxzeXN0ZW2qA3siaWQiOiJLaW5ldGljYSAzMDAtMzAzLXUzMC12MTAwIiwic3RhcnRfdGlt + ZSI6MTcwODEwMzQ1Miwic3RhdHVzIjoicnVubmluZyIsImNsdXN0ZXJfbGVhZGVyIjoiMTcyLjMx + LjMzLjMwIiwidmVyc2lvbiI6MjUsImNsdXN0ZXJfb3BlcmF0aW9uX3J1bm5pbmciOiJmYWxzZSIs + ImNsdXN0ZXJfb3BlcmF0aW9uX3N0YXR1cyI6IiIsIm9mZmxpbmVfc3RhdHVzIjoiZmFsc2UifQh0 + ZXh03AV7ImNvdW50Ijo4LCJzdGF0dXMiOlt7InZlcnNpb24iOjMzLCJyYW5rIjoxLCJzdGF0dXMi + OiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6Miwic3RhdHVzIjoicnVubmluZyJ9LHsi + dmVyc2lvbiI6MzMsInJhbmsiOjMsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24iOjMzLCJy + YW5rIjo0LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6NSwic3RhdHVz + IjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzMsInJhbmsiOjYsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjMzLCJyYW5rIjo3LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywi + cmFuayI6OCwic3RhdHVzIjoicnVubmluZyJ9XX0QdHJpZ2dlcnNeeyJ0b3RhbF9jb3VudCI6MCwi + cmFuZ2VfY291bnQiOjAsIm5haV9jb3VudCI6MH0AAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:37 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00061' + status: + code: 200 + message: OK +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/properties + response: + body: + string: !!binary | + BE9LAD5zaG93X3N5c3RlbV9wcm9wZXJ0aWVzX3Jlc3BvbnNlvPUCpAk8Y29uZi5haS5hcGkuY29u + bmVjdGlvbl90aW1lb3V0BDkwHmNvbmYuYWkuYXBpLmtleQAoY29uZi5haS5hcGkucHJvdmlkZXIW + a2luZXRpY2FsbG0eY29uZi5haS5hcGkudXJsSGh0dHA6Ly8xNzIuMzEuMzEuMTM6ODA1MC9zcWwv + c3VnZ2VzdDBjb25mLmFsZXJ0X2Rpc2tfYWJzb2x1dGUANGNvbmYuYWxlcnRfZGlza19wZXJjZW50 + YWdlGDEsIDUsIDEwLCAyMBxjb25mLmFsZXJ0X2V4ZQAsY29uZi5hbGVydF9ob3N0X3N0YXR1cwhU + UlVFOmNvbmYuYWxlcnRfaG9zdF9zdGF0dXNfZmlsdGVyIGZhdGFsX2luaXRfZXJyb3I4Y29uZi5h + bGVydF9tYXhfc3RvcmVkX2FsZXJ0cwYxMDA0Y29uZi5hbGVydF9tZW1vcnlfYWJzb2x1dGUAOGNv + bmYuYWxlcnRfbWVtb3J5X3BlcmNlbnRhZ2UYMSwgNSwgMTAsIDIwNGNvbmYuYWxlcnRfcmFua19j + dWRhX2Vycm9yCFRSVUVEY29uZi5hbGVydF9yYW5rX2ZhbGxiYWNrX2FsbG9jYXRvcghUUlVFLGNv + bmYuYWxlcnRfcmFua19zdGF0dXMIVFJVRTpjb25mLmFsZXJ0X3Jhbmtfc3RhdHVzX2ZpbHRlclhm + YXRhbF9pbml0X2Vycm9yLCBub3RfcmVzcG9uZGluZywgdGVybWluYXRlZB5jb25mLmF1ZGl0X2Jv + ZHkKRkFMU0UeY29uZi5hdWRpdF9kYXRhCkZBTFNFJGNvbmYuYXVkaXRfaGVhZGVycwpGQUxTRT5j + b25mLmF1dG9fY3JlYXRlX2V4dGVybmFsX3VzZXJzCkZBTFNFTGNvbmYuYnVpbGRfbWF0ZXJpYWxp + emVkX3ZpZXdzX29uX3N0YXJ0Em9uX2RlbWFuZDhjb25mLmJ1aWxkX3BrX2luZGV4X29uX3N0YXJ0 + Em9uX2RlbWFuZDhjb25mLmNodW5rX2NvbHVtbl9tYXhfbWVtb3J5EjUxMjAwMDAwMCpjb25mLmNo + dW5rX21heF9tZW1vcnkUODE5MjAwMDAwMB5jb25mLmNodW5rX3NpemUOODAwMDAwMCJjb25mLmNs + dXN0ZXJfbmFtZRxwcm9kdWN0aW9uLW5ld0Bjb25mLmNvbmN1cnJlbnRfa2VybmVsX2V4ZWN1dGlv + bghUUlVFOmNvbmYuZGVmYXVsdF9wcmltYXJ5X2tleV90eXBlDG1lbW9yeSBjb25mLmRlZmF1bHRf + dHRsBDIwLGNvbmYuZGlzYWJsZV9jbGVhcl9hbGwIVFJVRT5jb25mLmVncmVzc19wYXJxdWV0X2Nv + bXByZXNzaW9uDHNuYXBweSRjb25mLmVuYWJsZV9hbGVydHMIVFJVRSJjb25mLmVuYWJsZV9hdWRp + dApGQUxTRTJjb25mLmVuYWJsZV9hdXRob3JpemF0aW9uCFRSVUVGY29uZi5lbmFibGVfZXh0ZXJu + YWxfYXV0aGVudGljYXRpb24KRkFMU0UwY29uZi5lbmFibGVfZ3JhcGhfc2VydmVyCFRSVUUcY29u + Zi5lbmFibGVfaGEKRkFMU0UuY29uZi5lbmFibGVfaHR0cGRfcHJveHkKRkFMU0UcY29uZi5lbmFi + bGVfbWwKRkFMU0U2Y29uZi5lbmFibGVfb3BlbmdsX3JlbmRlcmVyCFRSVUVAY29uZi5lbmFibGVf + b3ZlcmxhcHBlZF9lcXVpX2pvaW4IVFJVRTRjb25mLmVuYWJsZV9wb3N0Z3Jlc19wcm94eQhUUlVF + PmNvbmYuZW5hYmxlX3ByZWRpY2F0ZV9lcXVpX2pvaW4IVFJVRSJjb25mLmVuYWJsZV9wcm9jcwhU + UlVFJGNvbmYuZW5hYmxlX3JldmVhbAhUUlVFMGNvbmYuZW5hYmxlX3N0YXRzX3NlcnZlcghUUlVF + LmNvbmYuZW5hYmxlX3RleHRfc2VhcmNoCFRSVUU8Y29uZi5lbmFibGVfdmVjdG9ydGlsZV9zZXJ2 + aWNlCFRSVUUsY29uZi5lbmFibGVfdnJhbV9jYWNoZQhUUlVFPmNvbmYuZW5hYmxlX3dvcmtlcl9o + dHRwX3NlcnZlcnMIVFJVRTJjb25mLmV2ZW50X3NlcnZlcl9hZGRyZXNzGDE3Mi4zMS4zMy4zMDRj + b25mLmV2ZW50X3NlcnZlcl9pbnRlcm5hbApGQUxTRTpjb25mLmV4dGVybmFsX2ZpbGVzX2RpcmVj + dG9yeSAvbmZzL2RhdGEvcHVibGljFGNvbmYuZ21faXAYMTcyLjMxLjMzLjMwGmNvbmYuZ21fcG9y + dDEINTU1MiBjb25mLmdtX3B1Yl9wb3J0CDU1NTMoY29uZi5ncmFwaC5oZWFkX3BvcnQIODEwMC5j + b25mLmdyYXBoLnNlcnZlcjAuaG9zdApob3N0MC5jb25mLmdyYXBoLnNlcnZlcjAucG9ydAg4MTAx + OGNvbmYuZ3JhcGguc2VydmVyMC5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjEuaG9zdApo + b3N0MS5jb25mLmdyYXBoLnNlcnZlcjEucG9ydAg4MTAyOGNvbmYuZ3JhcGguc2VydmVyMS5yYW1f + bGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjIuaG9zdApob3N0Mi5jb25mLmdyYXBoLnNlcnZlcjIu + cG9ydAg4MTAzOGNvbmYuZ3JhcGguc2VydmVyMi5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZl + cjMuaG9zdApob3N0My5jb25mLmdyYXBoLnNlcnZlcjMucG9ydAg4MTA0OGNvbmYuZ3JhcGguc2Vy + dmVyMy5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjQuaG9zdApob3N0NC5jb25mLmdyYXBo + LnNlcnZlcjQucG9ydAg4MTA1OGNvbmYuZ3JhcGguc2VydmVyNC5yYW1fbGltaXQCMC5jb25mLmdy + YXBoLnNlcnZlcjUuaG9zdApob3N0NS5jb25mLmdyYXBoLnNlcnZlcjUucG9ydAg4MTA2OGNvbmYu + Z3JhcGguc2VydmVyNS5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjYuaG9zdApob3N0Ni5j + b25mLmdyYXBoLnNlcnZlcjYucG9ydAg4MTA3OGNvbmYuZ3JhcGguc2VydmVyNi5yYW1fbGltaXQC + MC5jb25mLmdyYXBoLnNlcnZlcjcuaG9zdApob3N0Ny5jb25mLmdyYXBoLnNlcnZlcjcucG9ydAg4 + MTA4OGNvbmYuZ3JhcGguc2VydmVyNy5yYW1fbGltaXQCMBxjb25mLmhhX3F1ZXVlcwAuY29uZi5o + YV9yaW5nX2hlYWRfbm9kZXMAKGNvbmYuaGVhZF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zMBxjb25m + LmhlYWRfcG9ydAg5MTkxImNvbmYuaG1faHR0cF9wb3J0CDkzMDA2Y29uZi5ob3N0MF9hY2NlcHRz + X2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDBfYWRkcmVzcxgxNzIuMzEuMzMuMzAeY29uZi5ob3N0 + MF9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8v + MTcyLjMxLjMzLjMwOjkzMDAsY29uZi5ob3N0MF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMz + LjMwMmNvbmYuaG9zdDBfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMwLGNvbmYuaG9zdDBfcHVi + bGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMChjb25mLmhvc3QwX3JhbV9saW1pdBg2NTY3Njc3 + OTk5OTk2Y29uZi5ob3N0MV9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDFfYWRkcmVz + cxgxNzIuMzEuMzMuMzEeY29uZi5ob3N0MV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MV9ob3N0X21h + bmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMxOjkzMDAsY29uZi5ob3N0MV9wcml2 + YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMxMmNvbmYuaG9zdDFfcHVibGljX2FkZHJlc3MYMTcy + LjMxLjMzLjMxLGNvbmYuaG9zdDFfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMShjb25m + Lmhvc3QxX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0Ml9hY2NlcHRzX2ZhaWxvdmVy + CkZBTFNFJGNvbmYuaG9zdDJfYWRkcmVzcxgxNzIuMzEuMzMuMzIeY29uZi5ob3N0Ml9ncHVzDjAs + MSwyLDNEY29uZi5ob3N0Ml9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMz + LjMyOjkzMDAsY29uZi5ob3N0Ml9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMyMmNvbmYu + aG9zdDJfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMyLGNvbmYuaG9zdDJfcHVibGljX3VybHMm + aHR0cDovLzE3Mi4zMS4zMy4zMihjb25mLmhvc3QyX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29u + Zi5ob3N0M19hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDNfYWRkcmVzcxgxNzIuMzEu + MzMuMzMeY29uZi5ob3N0M19ncHVzDjAsMSwyLDNEY29uZi5ob3N0M19ob3N0X21hbmFnZXJfcHVi + bGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMzOjkzMDAsY29uZi5ob3N0M19wcml2YXRlX3VybCZo + dHRwOi8vMTcyLjMxLjMzLjMzMmNvbmYuaG9zdDNfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMz + LGNvbmYuaG9zdDNfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMyhjb25mLmhvc3QzX3Jh + bV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NF9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNv + bmYuaG9zdDRfYWRkcmVzcxgxNzIuMzEuMzMuMzQeY29uZi5ob3N0NF9ncHVzDjAsMSwyLDNEY29u + Zi5ob3N0NF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM0OjkzMDAs + Y29uZi5ob3N0NF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM0MmNvbmYuaG9zdDRfcHVi + bGljX2FkZHJlc3MYMTcyLjMxLjMzLjM0LGNvbmYuaG9zdDRfcHVibGljX3VybHMmaHR0cDovLzE3 + Mi4zMS4zMy4zNChjb25mLmhvc3Q0X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NV9h + Y2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDVfYWRkcmVzcxgxNzIuMzEuMzMuMzUeY29u + Zi5ob3N0NV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0NV9ob3N0X21hbmFnZXJfcHVibGljX3VybDBo + dHRwOi8vMTcyLjMxLjMzLjM1OjkzMDAsY29uZi5ob3N0NV9wcml2YXRlX3VybCZodHRwOi8vMTcy + LjMxLjMzLjM1MmNvbmYuaG9zdDVfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM1LGNvbmYuaG9z + dDVfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNShjb25mLmhvc3Q1X3JhbV9saW1pdBg2 + NTY3Njc3OTk5OTk2Y29uZi5ob3N0Nl9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDZf + YWRkcmVzcxgxNzIuMzEuMzMuMzYeY29uZi5ob3N0Nl9ncHVzDjAsMSwyLDNEY29uZi5ob3N0Nl9o + b3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM2OjkzMDAsY29uZi5ob3N0 + Nl9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM2MmNvbmYuaG9zdDZfcHVibGljX2FkZHJl + c3MYMTcyLjMxLjMzLjM2LGNvbmYuaG9zdDZfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4z + Nihjb25mLmhvc3Q2X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0N19hY2NlcHRzX2Zh + aWxvdmVyCkZBTFNFJGNvbmYuaG9zdDdfYWRkcmVzcxgxNzIuMzEuMzMuMzceY29uZi5ob3N0N19n + cHVzDjAsMSwyLDNEY29uZi5ob3N0N19ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcy + LjMxLjMzLjM3OjkzMDAsY29uZi5ob3N0N19wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM3 + MmNvbmYuaG9zdDdfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM3LGNvbmYuaG9zdDdfcHVibGlj + X3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNyhjb25mLmhvc3Q3X3JhbV9saW1pdBg2NTY3Njc3OTk5 + OTkqY29uZi5odHRwZF9wcm94eV9wb3J0CDgwODI0Y29uZi5odHRwZF9wcm94eV91c2VfaHR0cHMK + RkFMU0U4Y29uZi5pbml0X3dpdGhfbm93X2F0X3dvcmtlcgpGQUxTRSpjb25mLmthZmthLmJhdGNo + X3NpemUIMTAwMC5jb25mLmthZmthLnBvbGxfdGltZW91dAIwKGNvbmYua2Fma2Eud2FpdF90aW1l + BDMwLmNvbmYua2VybmVsX29tcF90aHJlYWRzAjQ0Y29uZi5sb2FkX3ZlY3RvcnNfb25fc3RhcnQS + b25fZGVtYW5kHmNvbmYubG9ja19hdWRpdApGQUxTRTZjb25mLm1heF9hdXRvX3ZpZXdfdXBkYXRv + cnMCMzZjb25mLm1heF9jb25jdXJyZW50X2tlcm5lbHMCMDJjb25mLm1heF9nZXRfcmVjb3Jkc19z + aXplCjIwMDAwKmNvbmYubWF4X2hlYXRtYXBfc2l6ZQgzMDcyKmNvbmYubWF4X2h0dHBfdGhyZWFk + cwY1MTI6Y29uZi5tZXRhZGF0YV9zdG9yZV9zeW5jX21vZGUMbm9ybWFsKmNvbmYubWluX2h0dHBf + dGhyZWFkcwI4MGNvbmYubWluX3Bhc3N3b3JkX2xlbmd0aAIwIGNvbmYubWxfYXBpX3BvcnQIOTE4 + N1xjb25mLm5wMS5idWlsZF9tYXRlcmlhbGl6ZWRfdmlld3Nfb25fbWlncmF0aW9uDGFsd2F5c0hj + b25mLm5wMS5idWlsZF9wa19pbmRleF9vbl9taWdyYXRpb24MYWx3YXlzRGNvbmYubnAxLmNyaXRp + Y2FsX3Jlc3RhcnRfYXR0ZW1wdHMCMTpjb25mLm5wMS5lbmFibGVfaGVhZF9mYWlsb3ZlcgpGQUxT + RT5jb25mLm5wMS5lbmFibGVfd29ya2VyX2ZhaWxvdmVyCkZBTFNFSmNvbmYubnAxLmZhaWxvdmVy + X2Rpc3RyaWJ1dGlvbl9wb2xpY3kIZmlsbERjb25mLm5wMS5sb2FkX3ZlY3RvcnNfb25fbWlncmF0 + aW9uDGFsd2F5c0xjb25mLm5wMS5ub25fY3JpdGljYWxfcmVzdGFydF9hdHRlbXB0cwIzPGNvbmYu + bnAxLnJhbmtfcmVzdGFydF9hdHRlbXB0cwIxMmNvbmYubnAxLnJlc3RhcnRfaW50ZXJ2YWwENjA2 + Y29uZi5ucDEuc3RvcmFnZV9hcGlfc2NyaXB0AChjb25mLm51bWJlcl9vZl9ob3N0cwI4KGNvbmYu + bnVtYmVyX29mX3JhbmtzAjk8Y29uZi5vcGVuZ2xfYW50aWFsaWFzaW5nX2xldmVsAjAsY29uZi5w + ZXJzaXN0X2RpcmVjdG9yeTAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8sY29uZi5wZXJzaXN0X3N5 + bmNfdGltZQI1NmNvbmYucG9pbnRfcmVuZGVyX3RocmVzaG9sZAwxMDAwMDBWY29uZi5wb3N0Z3Jl + c19wcm94eS5pZGxlX2Nvbm5lY3Rpb25fdGltZW91dAYzMDBUY29uZi5wb3N0Z3Jlc19wcm94eS5t + YXhfcXVldWVkX2Nvbm5lY3Rpb25zAjE+Y29uZi5wb3N0Z3Jlc19wcm94eS5tYXhfdGhyZWFkcwQ2 + ND5jb25mLnBvc3RncmVzX3Byb3h5Lm1pbl90aHJlYWRzAjIwY29uZi5wb3N0Z3Jlc19wcm94eS5w + b3J0CDU0MzIuY29uZi5wb3N0Z3Jlc19wcm94eS5zc2wIVFJVRRxjb25mLnJhbmswX2dwdQIwKmNv + bmYucmFuazBfaXBfYWRkcmVzcxgxNzIuMzEuMzMuMzAqY29uZi5yYW5rMV9pcF9hZGRyZXNzGDE3 + Mi4zMS4zMy4zMCpjb25mLnJhbmsyX2lwX2FkZHJlc3MYMTcyLjMxLjMzLjMxKmNvbmYucmFuazNf + aXBfYWRkcmVzcxgxNzIuMzEuMzMuMzIqY29uZi5yYW5rNF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4z + Mypjb25mLnJhbms1X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM0KmNvbmYucmFuazZfaXBfYWRkcmVz + cxgxNzIuMzEuMzMuMzUqY29uZi5yYW5rN19pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zNipjb25mLnJh + bms4X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM3KGNvbmYucmVxdWVzdF90aW1lb3V0CDI0MDA2Y29u + Zi5yZXF1aXJlX2F1dGhlbnRpY2F0aW9uCFRSVUVeY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0 + Lm1heF9jcHVfY29uY3VycmVuY3kELTFaY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0Lm1heF90 + aWVyX3ByaW9yaXR5BDEwSmNvbmYucmVzb3VyY2VfZ3JvdXAuZGVmYXVsdC5yYW1fbGltaXQELTFa + Y29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0LnNjaGVkdWxlX3ByaW9yaXR5BDUwTGNvbmYucmVz + b3VyY2VfZ3JvdXAuZGVmYXVsdC52cmFtX2xpbWl0BC0xHGNvbmYucmluZ19uYW1lDmRlZmF1bHRW + Y29uZi5zZWN1cml0eS5leHRlcm5hbC5yYW5nZXIuY2FjaGVfbWludXRlcwQ2MFRjb25mLnNlY3Vy + aXR5LmV4dGVybmFsLnJhbmdlci5zZXJ2aWNlX25hbWUQa2luZXRpY2FCY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXIudXJsAGBjb25mLnNlY3VyaXR5LmV4dGVybmFsLnJhbmdlcl9hdXRob3Jp + emVyLmFkZHJlc3MyaXBjOi8vL3RtcC9ncHVkYi1yYW5nZXItMHRjb25mLnNlY3VyaXR5LmV4dGVy + bmFsLnJhbmdlcl9hdXRob3JpemVyLnJlbW90ZV9kZWJ1Z19wb3J0AjBgY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXJfYXV0aG9yaXplci50aW1lb3V0BjEyMCpjb25mLnNldF9tb25pdG9yX3Bv + cnQIOTAwMjZjb25mLnNldF9tb25pdG9yX3Byb3h5X3BvcnQIOTAwMzZjb25mLnNldF9tb25pdG9y + X3F1ZXVlX3NpemUIMTAwMChjb25mLnNoYWRvd19hZ2dfc2l6ZRI1MDAwMDAwMDAwY29uZi5zaGFk + b3dfY3ViZV9lbmFibGVkCFRSVUUuY29uZi5zaGFkb3dfZmlsdGVyX3NpemUSNTAwMDAwMDAwJmNv + bmYuc21fb21wX3RocmVhZHMCMiRjb25mLnNtc19kaXJlY3RvcnkwL21udC9kYXRhL2dwdWRiL3Bl + cnNpc3QvLmNvbmYuc21zX21heF9vcGVuX2ZpbGVzBjEyOEBjb25mLnNxbC5jb3N0X2Jhc2VkX29w + dGltaXphdGlvbgpGQUxTRTRjb25mLnNxbC5kaXN0cmlidXRlZF9qb2lucwhUUlVFPmNvbmYuc3Fs + LmRpc3RyaWJ1dGVkX29wZXJhdGlvbnMIVFJVRS5jb25mLnNxbC5lbmFibGVfcGxhbm5lcghUUlVF + NmNvbmYuc3FsLmZvcmNlX2JpbmFyeV9qb2lucwpGQUxTRTpjb25mLnNxbC5mb3JjZV9iaW5hcnlf + c2V0X29wcwpGQUxTRTZjb25mLnNxbC5tYXhfcGFyYWxsZWxfc3RlcHMCNEBjb25mLnNxbC5tYXhf + dmlld19uZXN0aW5nX2xldmVscwQxNjJjb25mLnNxbC5wYWdpbmdfdGFibGVfdHRsBDIwNmNvbmYu + c3FsLnBhcmFsbGVsX2V4ZWN1dGlvbghUUlVFMGNvbmYuc3FsLnBsYW5fY2FjaGVfc2l6ZQg0MDAw + MGNvbmYuc3FsLnBsYW5uZXIuYWRkcmVzcz5pcGM6Ly8vdG1wL2dwdWRiLXF1ZXJ5LWVuZ2luZS0w + NmNvbmYuc3FsLnBsYW5uZXIubWF4X21lbW9yeQg0MDk2NGNvbmYuc3FsLnBsYW5uZXIubWF4X3N0 + YWNrAjZEY29uZi5zcWwucGxhbm5lci5yZW1vdGVfZGVidWdfcG9ydAIwMGNvbmYuc3FsLnBsYW5u + ZXIudGltZW91dAYxMjA0Y29uZi5zcWwucmVzdWx0X2NhY2hlX3NpemUINDAwMDRjb25mLnNxbC5y + ZXN1bHRzLmNhY2hlX3R0bAQ2MDBjb25mLnNxbC5yZXN1bHRzLmNhY2hpbmcIVFJVRUBjb25mLnNx + bC5ydWxlX2Jhc2VkX29wdGltaXphdGlvbghUUlVFPGNvbmYuc3VidGFza19jb25jdXJyZW5jeV9s + aW1pdAI0PmNvbmYuc3ltYm9sb2d5X3JlbmRlcl90aHJlc2hvbGQKMTAwMDBQY29uZi5zeXN0ZW1f + bWV0YWRhdGEuc3RhdHNfYWdncl9yb3djb3VudAoxMDAwMEhjb25mLnN5c3RlbV9tZXRhZGF0YS5z + dGF0c19hZ2dyX3RpbWUCMVJjb25mLnN5c3RlbV9tZXRhZGF0YS5zdGF0c19yZXRlbnRpb25fZGF5 + cwQyMSZjb25mLnRhc2tjYWxjX2dwdS4xElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4yElsw + LDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4zElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS40 + ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS41ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dw + dS42ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS43ElswLDEsMiwzXSZjb25mLnRhc2tjYWxj + X2dwdS44ElswLDEsMiwzXSBjb25mLnRjc19wZXJfdG9tBDQwJmNvbmYudGVtcF9kaXJlY3RvcnkI + L3RtcDJjb25mLnRleHRfaW5kZXhfZGlyZWN0b3J5MC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0LzJj + b25mLnRleHRfaW5kaWNlc19wZXJfdG9tAjJMY29uZi50aWVyLmRpc2swLmRlZmF1bHQuaGlnaF93 + YXRlcm1hcmsEOTA6Y29uZi50aWVyLmRpc2swLmRlZmF1bHQubGltaXQYNjAwMDAwMDAwMDAwSmNv + bmYudGllci5kaXNrMC5kZWZhdWx0Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLmRpc2swLmRl + ZmF1bHQucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlYGNvbmYudGllci5k + aXNrMC5kZWZhdWx0LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlz + azAucmFuazAuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbmswLmxpbWl0GDYw + MDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazAubG93X3dhdGVybWFyawQ4MDRjb25mLnRp + ZXIuZGlzazAucmFuazAucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNv + bmYudGllci5kaXNrMC5yYW5rMC5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50 + aWVyLmRpc2swLnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rMS5s + aW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJhbmsxLmxvd193YXRlcm1hcmsEODA0 + Y29uZi50aWVyLmRpc2swLnJhbmsxLnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tj + YWNoZVxjb25mLnRpZXIuZGlzazAucmFuazEuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNF + SGNvbmYudGllci5kaXNrMC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAu + cmFuazIubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rMi5sb3dfd2F0ZXJt + YXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rMi5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0 + Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbmsyLnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0 + cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazMuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVy + LmRpc2swLnJhbmszLmxpbWl0GDYwMDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazMubG93 + X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazMucGF0aEQvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5yYW5rMy5zdG9yZV9wZXJzaXN0ZW50 + X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNv + bmYudGllci5kaXNrMC5yYW5rNC5saW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJh + bms0Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2swLnJhbms0LnBhdGhEL21udC9kYXRh + L2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIuZGlzazAucmFuazQuc3RvcmVfcGVy + c2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNrMC5yYW5rNS5oaWdoX3dhdGVybWFy + awQ5MDZjb25mLnRpZXIuZGlzazAucmFuazUubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5k + aXNrMC5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rNS5wYXRoRC9t + bnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbms1LnN0 + b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazYuaGlnaF93 + YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbms2LmxpbWl0GDYwMDAwMDAwMDAwMEZjb25m + LnRpZXIuZGlzazAucmFuazYubG93X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazYu + cGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5y + YW5rNi5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms3 + LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rNy5saW1pdBg2MDAwMDAwMDAw + MDBGY29uZi50aWVyLmRpc2swLnJhbms3Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2sw + LnJhbms3LnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIu + ZGlzazAucmFuazcuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNr + MC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAucmFuazgubGltaXQYNjAw + MDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGll + ci5kaXNrMC5yYW5rOC5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29u + Zi50aWVyLmRpc2swLnJhbms4LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRVBjb25mLnRp + ZXIuZ2xvYmFsLmNvbmN1cnJlbnRfd2FpdF90aW1lb3V0BjYwMGpjb25mLnRpZXIuZ2xvYmFsLmRl + ZmVyX2NhY2hlX29iamVjdF9ldmljdGlvbnNfdG9fZGlzawhUUlVFUGNvbmYudGllci5wZXJzaXN0 + LmRlZmF1bHQuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnBlcnNpc3QuZGVmYXVsdC5saW1p + dBo2NTAwMDAwMDAwMDAwTmNvbmYudGllci5wZXJzaXN0LmRlZmF1bHQubG93X3dhdGVybWFyawQ4 + MDxjb25mLnRpZXIucGVyc2lzdC5kZWZhdWx0LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3Qv + OmNvbmYudGllci5wZXJzaXN0LmdyYXBoMC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpj + b25mLnRpZXIucGVyc2lzdC5ncmFwaDEucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29u + Zi50aWVyLnBlcnNpc3QuZ3JhcGgyLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYu + dGllci5wZXJzaXN0LmdyYXBoMy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRp + ZXIucGVyc2lzdC5ncmFwaDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29uZi50aWVy + LnBlcnNpc3QuZ3JhcGg1LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYudGllci5w + ZXJzaXN0LmdyYXBoNi5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRpZXIucGVy + c2lzdC5ncmFwaDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNp + c3QucmFuazAuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazAubGltaXQa + NjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwOGNv + bmYudGllci5wZXJzaXN0LnJhbmswLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYu + dGllci5wZXJzaXN0LnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJh + bmsxLmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazEubG93X3dhdGVy + bWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rMS5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJz + aXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIu + cGVyc2lzdC5yYW5rMi5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbmsy + Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazIucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNpc3QucmFuazMuaGlnaF93YXRlcm1hcmsEOTA6 + Y29uZi50aWVyLnBlcnNpc3QucmFuazMubGltaXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVy + c2lzdC5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwOGNvbmYudGllci5wZXJzaXN0LnJhbmszLnBhdGgw + L21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYudGllci5wZXJzaXN0LnJhbms0LmhpZ2hfd2F0 + ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJhbms0LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29u + Zi50aWVyLnBlcnNpc3QucmFuazQubG93X3dhdGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5y + YW5rNC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5r + NS5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIucGVyc2lzdC5yYW5rNS5saW1pdBo2NTAwMDAw + MDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbms1Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVy + LnBlcnNpc3QucmFuazUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBl + cnNpc3QucmFuazYuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazYubGlt + aXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgw + OGNvbmYudGllci5wZXJzaXN0LnJhbms2LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNv + bmYudGllci5wZXJzaXN0LnJhbms3LmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0 + LnJhbms3LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazcubG93X3dh + dGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rNy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9w + ZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRp + ZXIucGVyc2lzdC5yYW5rOC5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJh + bms4Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazgucGF0aDAvbW50L2Rh + dGEvZ3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDEucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDIucGF0aDAvbW50L2RhdGEvZ3B1 + ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDMucGF0aDAvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVy + c2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lz + dC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDYucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84 + Y29uZi50aWVyLnBlcnNpc3QudGV4dDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84Y29u + Zi50aWVyLnBlcnNpc3QudGV4dDgucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9IY29uZi50 + aWVyLnJhbS5kZWZhdWx0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5yYW0uZGVmYXVsdC5s + aW1pdAQtMUZjb25mLnRpZXIucmFtLmRlZmF1bHQubG93X3dhdGVybWFyawQ4MERjb25mLnRpZXIu + cmFtLnJhbmswLmhpZ2hfd2F0ZXJtYXJrBDkwMmNvbmYudGllci5yYW0ucmFuazAubGltaXQWNzcy + NjY4MDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazEuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazIuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazMuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazQuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazUuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazYuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazcuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazguaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rOC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwXGNvbmYudGllci52 + cmFtLmRlZmF1bHQuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBKY29uZi50aWVyLnZyYW0uZGVm + YXVsdC5hbGxfZ3B1cy5saW1pdAQtMVpjb25mLnRpZXIudnJhbS5kZWZhdWx0LmFsbF9ncHVzLmxv + d193YXRlcm1hcmsEODBUY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUwLmhpZ2hfd2F0ZXJtYXJr + BDkwQmNvbmYudGllci52cmFtLmRlZmF1bHQuZ3B1MC5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5k + ZWZhdWx0LmdwdTAubG93X3dhdGVybWFyawQ4MFRjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTEu + aGlnaF93YXRlcm1hcmsEOTBCY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUxLmxpbWl0BC0xUmNv + bmYudGllci52cmFtLmRlZmF1bHQuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwVGNvbmYudGllci52cmFt + LmRlZmF1bHQuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MEJjb25mLnRpZXIudnJhbS5kZWZhdWx0Lmdw + dTIubGltaXQELTFSY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUyLmxvd193YXRlcm1hcmsEODBU + Y29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwQmNvbmYudGllci52 + cmFtLmRlZmF1bHQuZ3B1My5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTMubG93 + X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMC5HUFUwLmhpZ2hfd2F0ZXJtYXJrBDkw + PmNvbmYudGllci52cmFtLnJhbmswLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAu + R1BVMC5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmhpZ2hf + d2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYu + dGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazAuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUwLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rMC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsw + LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbmswLmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazAuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUyLmxvd193YXRl + cm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25m + LnRpZXIudnJhbS5yYW5rMC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTMu + bG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5HUFUwLmhpZ2hfd2F0ZXJtYXJr + BDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFu + azEuR1BVMC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLkdQVTEuaGlnaF93 + YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuR1BVMS5saW1pdAQtMU5jb25mLnRpZXIu + dnJhbS5yYW5rMS5HUFUxLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuR1BV + Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5HUFUyLmxpbWl0BC0xTmNv + bmYudGllci52cmFtLnJhbmsxLkdQVTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5y + YW5rMS5HUFUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTMubGlt + aXQELTFOY29uZi50aWVyLnZyYW0ucmFuazEuR1BVMy5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGll + ci52cmFtLnJhbmsxLmFsbF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJh + bmsxLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGllci52cmFtLnJhbmsxLmFsbF9ncHVzLmxvd193 + YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5j + b25mLnRpZXIudnJhbS5yYW5rMS5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsxLmdw + dTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5ncHUxLmhpZ2hfd2F0ZXJt + YXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0u + cmFuazEuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLmdwdTIuaGln + aF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuZ3B1Mi5saW1pdAQtMU5jb25mLnRp + ZXIudnJhbS5yYW5rMS5ncHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEu + Z3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5ncHUzLmxpbWl0BC0x + TmNvbmYudGllci52cmFtLnJhbmsxLmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJh + bS5yYW5rMi5hbGxfZ3B1cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rMi5h + bGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJhbS5yYW5rMi5hbGxfZ3B1cy5sb3dfd2F0ZXJt + YXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50 + aWVyLnZyYW0ucmFuazIuZ3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUwLmxv + d193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazIuZ3B1MS5oaWdoX3dhdGVybWFyawQ5 + MD5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsy + LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMi5ncHUyLmhpZ2hfd2F0 + ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsyLmdwdTIubGltaXQELTFOY29uZi50aWVyLnZy + YW0ucmFuazIuZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTMu + aGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazIuZ3B1My5saW1pdAQtMU5jb25m + LnRpZXIudnJhbS5yYW5rMi5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFu + azMuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dw + dXMubGltaXQELTFWY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4 + MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52 + cmFtLnJhbmszLmdwdTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1MC5sb3dfd2F0 + ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmszLmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29u + Zi50aWVyLnZyYW0ucmFuazMuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUx + Lmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1Mi5oaWdoX3dhdGVybWFy + awQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJh + bmszLmdwdTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUzLmhpZ2hf + d2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmszLmdwdTMubGltaXQELTFOY29uZi50aWVy + LnZyYW0ucmFuazMuZ3B1My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms0LmFs + bF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxp + bWl0BC0xVmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29u + Zi50aWVyLnZyYW0ucmFuazQuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5y + YW5rNC5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms0LmdwdTAubG93X3dhdGVybWFy + awQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGll + ci52cmFtLnJhbms0LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1MS5sb3df + d2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms0LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+ + Y29uZi50aWVyLnZyYW0ucmFuazQuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNC5n + cHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1My5oaWdoX3dhdGVy + bWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFt + LnJhbms0LmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1 + cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5saW1pdAQt + MVZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGll + ci52cmFtLnJhbms1LmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazUu + Z3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNS5ncHUwLmxvd193YXRlcm1hcmsEODBQ + Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJh + bS5yYW5rNS5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms1LmdwdTEubG93X3dhdGVy + bWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNS5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYu + dGllci52cmFtLnJhbms1LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazUuZ3B1Mi5s + b3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms1LmdwdTMuaGlnaF93YXRlcm1hcmsE + OTA+Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5r + NS5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMuaGln + aF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubGltaXQELTFWY29u + Zi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJh + bS5yYW5rNi5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms2LmdwdTAu + bGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1MC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYu + dGllci52cmFtLnJhbms2LmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFu + azYuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNi5ncHUxLmxvd193YXRlcm1hcmsE + ODBQY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIu + dnJhbS5yYW5rNi5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms2LmdwdTIubG93X3dh + dGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNi5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNv + bmYudGllci52cmFtLnJhbms2LmdwdTMubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1 + My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmhpZ2hfd2F0 + ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGll + ci52cmFtLnJhbms3LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFu + azcuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUwLmxpbWl0 + BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIu + dnJhbS5yYW5rNy5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms3Lmdw + dTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNv + bmYudGllci52cmFtLnJhbms3LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0u + cmFuazcuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUyLmxvd193YXRlcm1h + cmsEODBQY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRp + ZXIudnJhbS5yYW5rNy5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTMubG93 + X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5oaWdoX3dhdGVybWFy + awQ5MEZjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJh + bS5yYW5rOC5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms4Lmdw + dTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazguZ3B1MC5saW1pdAQtMU5j + b25mLnRpZXIudnJhbS5yYW5rOC5ncHUwLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazguZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUxLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbms4LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rOC5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms4 + LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazguZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbms4LmdwdTMuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazguZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUzLmxvd193YXRl + cm1hcmsEODA0Y29uZi50aWVyX3N0cmF0ZWd5LmRlZmF1bHRCVlJBTSAyLCBSQU0gNSwgRElTSzAg + NSwgUEVSU0lTVCA1YGNvbmYudGllcl9zdHJhdGVneS5wcmVkaWNhdGVfZXZhbHVhdGlvbl9pbnRl + cnZhbAQ2MCRjb25mLnRvbXNfcGVyX3JhbmsCMSBjb25mLnRwc19wZXJfdG9tBDQwImNvbmYudHJp + Z2dlcl9wb3J0CDkwMDE+Y29uZi51bmlmaWVkX3NlY3VyaXR5X25hbWVzcGFjZQpGQUxTRTpjb25m + LnVzZV9leHRlcm5hbF90ZXh0X3NlcnZlcghUUlVFHGNvbmYudXNlX2h0dHBzCkZBTFNFLGNvbmYu + dmlkZW9fZGVmYXVsdF90dGwELTEoY29uZi52aWRlb19tYXhfY291bnQELTEyY29uZi52aWRlb190 + ZW1wX2RpcmVjdG9yeSwvdG1wL2dwdWRiLXRlbXAtdmlkZW9zImNvbmYud2FsLmNoZWNrc3VtCFRS + VUUwY29uZi53YWwuZmx1c2hfZnJlcXVlbmN5BDYwMmNvbmYud2FsLm1heF9zZWdtZW50X3NpemUS + NTAwMDAwMDAwLGNvbmYud2FsLnNlZ21lbnRfY291bnQELTEoY29uZi53YWwuc3luY19wb2xpY3kK + Zmx1c2g2Y29uZi53b3JrZXJfaHR0cF9zZXJ2ZXJfaXBz6AExNzIuMzEuMzMuMzA7MTcyLjMxLjMz + LjMwOzE3Mi4zMS4zMy4zMTsxNzIuMzEuMzMuMzI7MTcyLjMxLjMzLjMzOzE3Mi4zMS4zMy4zNDsx + NzIuMzEuMzMuMzU7MTcyLjMxLjMzLjM2OzE3Mi4zMS4zMy4zNzpjb25mLndvcmtlcl9odHRwX3Nl + cnZlcl9wb3J0c1g5MTkxOzkxOTI7OTE5Mzs5MTk0OzkxOTU7OTE5Njs5MTk3OzkxOTg7OTE5OThj + b25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzwANodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTE7aHR0 + cDovLzE3Mi4zMS4zMy4zMDo5MTkyO2h0dHA6Ly8xNzIuMzEuMzMuMzE6OTE5MztodHRwOi8vMTcy + LjMxLjMzLjMyOjkxOTQ7aHR0cDovLzE3Mi4zMS4zMy4zMzo5MTk1O2h0dHA6Ly8xNzIuMzEuMzMu + MzQ6OTE5NjtodHRwOi8vMTcyLjMxLjMzLjM1OjkxOTc7aHR0cDovLzE3Mi4zMS4zMy4zNjo5MTk4 + O2h0dHA6Ly8xNzIuMzEuMzMuMzc6OTE5OUhjb25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzX3By + aXZhdGXAA2h0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MTtodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTI7 + aHR0cDovLzE3Mi4zMS4zMy4zMTo5MTkzO2h0dHA6Ly8xNzIuMzEuMzMuMzI6OTE5NDtodHRwOi8v + MTcyLjMxLjMzLjMzOjkxOTU7aHR0cDovLzE3Mi4zMS4zMy4zNDo5MTk2O2h0dHA6Ly8xNzIuMzEu + MzMuMzU6OTE5NztodHRwOi8vMTcyLjMxLjMzLjM2OjkxOTg7aHR0cDovLzE3Mi4zMS4zMy4zNzo5 + MTk5KHN5c3RlbS5mb250X2ZhbWlsaWVzpgFEZWphVnUgTWF0aCBUZVggR3lyZSxEZWphVnUgU2Fu + cyBNb25vLERlamFWdSBTYW5zLERlamFWdSBTZXJpZixTYW5zLFNlcmlmLE1vbm9zcGFjZTB2ZXJz + aW9uLmdwdWRiX2J1aWxkX2RhdGUoRmViIDE0IDIwMjQgMjM6NDk6MDFAdmVyc2lvbi5ncHVkYl9j + b21wdXRlX2NhcGFiaWxpdHkWNjA7NzA7ODA7ODY4dmVyc2lvbi5ncHVkYl9jb21wdXRlX2VuZ2lu + ZQhDVURBPnZlcnNpb24uZ3B1ZGJfY29yZV9saWJzX3ZlcnNpb24UMjAyNDAyMTMwMDR2ZXJzaW9u + LmdwdWRiX2NvcmVfdmVyc2lvbiw3LjIuMC4xLjIwMjQwMjE0MjEwOTA2NHZlcnNpb24uZ3B1ZGJf + ZmlsZV92ZXJzaW9uFDIwMjEwMzExMjAqdmVyc2lvbi5ncHVkYl92ZXJzaW9uUDkyMjYwYTMyOWNh + NDVjYjBlMzc3NzZjZjkxNDQ5NzE3OWY2MjExNDM0dmVyc2lvbi5ncHVkYl92ZXJzaW9uX2RhdGUy + MjAyNC0wMi0xNCAyMTowOTowNiAtMDUwMCx2ZXJzaW9uLnB5dGhvbl92ZXJzaW9uDjMuMTAuMTMA + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:37 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00057' + status: + code: 200 + message: OK +- request: + body: !!binary | + hAFHRU5FUkFURSBQUk9NUFQgV0lUSCBPUFRJT05TIChDT05URVhUX05BTUVTID0gJ2RlbW8udGVz + dF9sbG1fY3R4JykAAgxiaW5hcnkAAAA= + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/execute/sql + response: + body: + string: !!binary | + BE9LAChleGVjdXRlX3NxbF9yZXNwb25zZe4MAPYDeyJuYW1lIjoiZ2VuZXJpY19yZXNwb25zZSIs + InR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJjb2x1bW5fMSIsInR5cGUiOnsidHlw + ZSI6ImFycmF5IiwiaXRlbXMiOiJzdHJpbmcifX0seyJuYW1lIjoiY29sdW1uX2hlYWRlcnMiLCJ0 + eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19LHsibmFtZSI6ImNvbHVtbl9k + YXRhdHlwZXMiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19XX2qBwL+ + BnsicGF5bG9hZCI6eyJjb250ZXh0IjpbeyJ0YWJsZSI6ImRlbW8udGVzdF9wcm9maWxlcyIsImNv + bHVtbnMiOlsidXNlcm5hbWUgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwibmFtZSBWQVJDSEFSICgz + MikgTk9UIE5VTEwiLCJzZXggVkFSQ0hBUiAoMSkgTk9UIE5VTEwiLCJhZGRyZXNzIFZBUkNIQVIg + KDY0KSBOT1QgTlVMTCIsIm1haWwgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwiYmlydGhkYXRlIFRJ + TUVTVEFNUCBOT1QgTlVMTCJdLCJkZXNjcmlwdGlvbiI6IkNvbnRhaW5zIHVzZXIgcHJvZmlsZXMu + IiwicnVsZXMiOltdfSx7InNhbXBsZXMiOnsiSG93IG1hbnkgbWFsZSB1c2VycyBhcmUgdGhlcmU/ + Ijoic2VsZWN0IGNvdW50KDEpIGFzIG51bV91c2Vyc1xuICAgICAgICAgICAgZnJvbSBkZW1vLnRl + c3RfcHJvZmlsZXNcbiAgICAgICAgICAgIHdoZXJlIHNleCA9ICcnTScnOyJ9fV19fQACDFByb21w + dAACDHN0cmluZwAAAgAACCBYLUtpbmV0aWNhLUdyb3VwBkRETApjb3VudAIwGmxhc3RfZW5kcG9p + bnQsL2dlbmVyYXRlL3NxbC9pbnRlcm5hbC50b3RhbF9udW1iZXJfb2ZfcmVjb3JkcwIwAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:37 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Kinetica-Group: + - DDL + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00666' + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "CREATE TABLE demo.test_profiles + AS\n(\n username VARCHAR (32) NOT NULL,\n name VARCHAR (32) NOT NULL,\n sex + VARCHAR (1) NOT NULL,\n address VARCHAR (64) NOT NULL,\n mail VARCHAR (32) + NOT NULL,\n birthdate TIMESTAMP NOT NULL\n);\nCOMMENT ON TABLE demo.test_profiles + IS ''Contains user profiles.'';"}, {"role": "user", "content": "How many male + users are there?"}, {"role": "assistant", "content": "select count(1) as num_users\n from + demo.test_profiles\n where sex = ''M'';"}, {"role": "user", "content": + "What are the female users ordered by username?"}]}' + headers: + Accept: + - text/plain + Content-type: + - application/json + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/chat/completions + response: + body: + string: '{"status":"OK","data":{"status":"OK","data":{"id":"chatCompl-1708561598","object":"chat.completion","created":1708561598,"model":"sqlassist-1.1","choices":[{"index":0,"message":{"role":"assistant","content":"SELECT + username, name\n FROM demo.test_profiles\n WHERE sex + = ''F''\n ORDER BY username;"},"finish_reason":"stop"}],"usage":{"prompt_tokens":140,"completion_tokens":22,"total_tokens":162},"prompt":"What + are the female users ordered by username?"}}}' + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/json + Date: + - Thu, 22 Feb 2024 00:26:37 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.90840' + status: + code: 200 + message: OK +version: 1 diff --git a/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_load_context.yaml b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_load_context.yaml new file mode 100644 index 0000000000..3825f7881f --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_load_context.yaml @@ -0,0 +1,767 @@ +interactions: +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/status + response: + body: + string: !!binary | + BE9LADZzaG93X3N5c3RlbV9zdGF0dXNfcmVzcG9uc2X8ugEUCmdyYXBovAl7ImNvdW50Ijo4LCJz + dGF0dXMiOlt7InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjAsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzAiLCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjoxLCJob3N0 + X2lkIjoiMTcyLjMxLjMzLjMxIiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNl + cnZlcl9pZCI6MiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMiIsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjMsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzMiLCJzdGF0 + dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo0LCJob3N0X2lkIjoiMTcy + LjMxLjMzLjM0Iiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNlcnZlcl9pZCI6 + NSwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNSIsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24i + OjM5LCJzZXJ2ZXJfaWQiOjYsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzYiLCJzdGF0dXMiOiJydW5u + aW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo3LCJob3N0X2lkIjoiMTcyLjMxLjMzLjM3 + Iiwic3RhdHVzIjoicnVubmluZyJ9XX0eaGFfY2x1c3Rlcl9pbmZvzAN7ImhhX3JhbmtzX2luZm8i + Olt7InByaXZhdGVfdXJsIjoiaHR0cDovLzE3Mi4zMS4zMy4zMDo5MTkxIiwicHVibGljX3VybCI6 + Imh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MSIsImhhX3VybF9vdmVycmlkZSI6Imh0dHA6Ly8xNzIu + MzEuMzMuMzA6OTE5MSIsImFsdGVybmF0ZV91cmxzIjpbImh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5 + MSJdfV0sInJlYWR5Ijp0cnVlLCJuYW1lIjoicHJvZHVjdGlvbi1uZXcifQpob3N0c/hLeyJjb3Vu + dCI6OCwic3RhdHVzIjpbeyJ2ZXJzaW9uIjoxMzMsImhvc3RfbnVtYmVyIjowLCJpZCI6IjE3Mi4z + MS4zMy4zMCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzAtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmci + LCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9z + dGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoicnVubmluZyIsInJldmVh + bF9zdGF0dXMiOiJydW5uaW5nIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEyNjAwMzIsInN0YXJ0X3Rp + bWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4zMCJdLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiLCJHUFUtNTNlMWI3YjQt + NjhiOC1hMjhjLTEwZjMtZGI2YTA1OTdmYmI0IiwiR1BVLTQxZmY5MWZiLWVjYjktMGE1Yi1kNDdj + LWQ1YmI3ZWYxMDM4YSIsIkdQVS1hOTQwYjEyNi1iMWE0LTlmMDctNDRlMS02MzZjMzc5ODllY2Yi + XSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoibGVhZGVyIiwiaG9zdF90 + ZXJtIjowLCJob3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9u + IjoxMTMsImhvc3RfbnVtYmVyIjoxLCJpZCI6IjE3Mi4zMS4zMy4zMSIsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzEtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxl + ZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5 + X3BsYW5uZXJfc3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90 + YWxfbWVtb3J5Ijo4MTAyMDEyMzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtf + aXBzIjpbIjE3Mi4zMS4zMy4zMSJdLCJncHVfaWRzIjpbIkdQVS0xMzJmMWRkYi1hNWY0LTIwZDMt + MTEyMi02ZDM1OTlhZmNmMWQiLCJHUFUtM2JjN2JmY2QtOTVhOS1hNjI2LThlOGYtMzdiOTcxOWFh + OWRkIiwiR1BVLWZlMTBhZDNkLTg4M2QtYTU5MC1kNDA1LWUwYTU2OTNiMGFmMCIsIkdQVS02Yjgy + OTY5OS0wYjRjLTEyZjAtMGMyOC04Y2Y0NmMyNGMxODUiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZh + bHNlIiwiaG9zdF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25f + c3RhdHVzIjoibGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjIs + ImlkIjoiMTcyLjMxLjMzLjMyIiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMi12MTAwIiwic3RhdHVz + IjoicnVubmluZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVu + bmluZyIsIm1sX3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9w + cGVkIiwicmV2ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTIzMTM2 + MCwic3RhcnRfdGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjMyIl0s + ImdwdV9pZHMiOlsiR1BVLTA5MGM0NDMwLWRiYmUtMWUxYS03ZjdmLWExODI3ODNhZDIzMSIsIkdQ + VS1iZTE0YjVjZS1iNDExLTQ4Y2EtYTlmZi01YTA2YzdhNmYzOTgiLCJHUFUtNGIxYTU2ODgtMGU4 + Yy1jYzk0LTgzM2ItYzJmMzllOTk1M2I4IiwiR1BVLTEyZWJhNDYzLTgzMmUtMTA4Yi1lY2IyLTVj + OWFmOGRhNjE2NCJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xs + b3dlciIsImhvc3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3Rl + ZCJ9LHsidmVyc2lvbiI6MTEzLCJob3N0X251bWJlciI6MywiaWQiOiIxNzIuMzEuMzMuMzMiLCJo + b3N0bmFtZSI6IjMwMC0zMDMtdTMzLXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3Rh + dHVzIjoiZGlzYWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlz + YWJsZWQiLCJxdWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoi + c3RvcHBlZCIsInRvdGFsX21lbW9yeSI6ODEwMjAxMjM5NTUyLCJzdGFydF90aW1lIjoxNzA4MTAz + NDUyLCJuZXR3b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzMiXSwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImFjY2VwdHNf + ZmFpbG92ZXIiOiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJo + b3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhv + c3RfbnVtYmVyIjo0LCJpZCI6IjE3Mi4zMS4zMy4zNCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzQt + djEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRz + X3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJf + c3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5 + Ijo4MTAyMDEyMTA4ODAsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3 + Mi4zMS4zMy4zNCJdLCJncHVfaWRzIjpbIkdQVS02OGUwOWNmYy1mOWE0LTJhMTQtNTdhNC05NDgz + YjkxYzJkOWEiLCJHUFUtM2RmMjE2ZTgtZmU3NC0wNDdhLTk1YWMtNzJlMmNiZWNiNTIyIiwiR1BV + LTE0ZDQ0Yjk4LWIwNDItY2I4MS0xZGQzLTIwZDRmNjljODljYSIsIkdQVS0zNDA2NzMwYi1iZWFk + LWM1MGEtNDZlYi1lMGEyYzJiZjZlNzYiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9z + dF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoi + bGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjUsImlkIjoiMTcy + LjMxLjMzLjM1IiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNS12MTAwIiwic3RhdHVzIjoicnVubmlu + ZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVubmluZyIsIm1s + X3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9wcGVkIiwicmV2 + ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTI0Nzc0NCwic3RhcnRf + dGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjM1Il0sImdwdV9pZHMi + OlsiR1BVLWY3MzAyYWJjLTllYWEtMTRjOS1mNDI2LTE2M2RmM2RhOGMyNiIsIkdQVS03N2RkN2Q0 + OC1mOTgwLWZkMDYtNzIyYy0xYzViOTMyMTgyMDMiLCJHUFUtNTUyYjIwYTUtNTdlNi00OTg2LWJl + MmItMmIzNzhmZDRiY2FhIiwiR1BVLTYzMDUzMTYyLTMwN2YtNTVjNS1hOTc0LTU4ZGZlODQzNDJi + MiJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xsb3dlciIsImhv + c3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3RlZCJ9LHsidmVy + c2lvbiI6MTEzLCJob3N0X251bWJlciI6NiwiaWQiOiIxNzIuMzEuMzMuMzYiLCJob3N0bmFtZSI6 + IjMwMC0zMDMtdTM2LXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3RhdHVzIjoiZGlz + YWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlzYWJsZWQiLCJx + dWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoic3RvcHBlZCIs + InRvdGFsX21lbW9yeSI6ODEwMjAxMjIzMTY4LCJzdGFydF90aW1lIjoxNzA4MTAzNDUyLCJuZXR3 + b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzYiXSwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04 + MmYwLTNmZTQtZjFmMmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZk + MDA1N2FiOCIsIkdQVS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUt + YWI3NTRhM2MtNjA4Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImFjY2VwdHNfZmFpbG92ZXIi + OiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJob3N0X2VsZWN0 + aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhvc3RfbnVtYmVy + Ijo3LCJpZCI6IjE3Mi4zMS4zMy4zNyIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzctdjEwMCIsInN0 + YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6 + InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoi + c3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEy + MzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4z + NyJdLCJncHVfaWRzIjpbIkdQVS1lYTE4ZDM4OC1lMmIzLTQyODMtYTZiNS1hMzIzYTQ4NzI1YTki + LCJHUFUtZGNkODRlZmItOTRjYS1iNDk3LThjMTUtN2EzMjY5NDBjMWViIiwiR1BVLTkxNjAxYTVl + LTk3M2YtZDFlNC02ZTFkLWY2NTUyOTRkMzQ2MCIsIkdQVS0wN2ZhNGRiNi05ZTU1LWI2MWYtOTA5 + YS04NWM0ZDFiZWIwODgiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoi + Zm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoibGVhZGVyX2Vs + ZWN0ZWQifV19Fmh0dHBfc2VydmVyoAN7ImNvbm5lY3Rpb25zIjp7ImN1cnJlbnQiOjEsIm1heF9j + b25jdXJyZW50IjoxMTYsInF1ZXVlZCI6MCwibWF4X3F1ZXVlZF9hbGxvd2VkIjo2NTUzNiwidG90 + YWwiOjMyNTg5NSwicmVmdXNlZCI6MCwidGhyZWFkcyI6Mn0sInRocmVhZHMiOnsidXNlZCI6Miwi + Y2FwYWNpdHkiOjUxMiwiYWxsb2NhdGVkIjo4LCJhdmFpbGFibGUiOjUxMCwic3RhY2tfc2l6ZSI6 + MH19FG1pZ3JhdGlvbnMueyJjb3VudCI6MCwic3RhdHVzIjpbXX0KcmFua3PgUnsiY291bnQiOjks + InN0YXR1cyI6W3sidmVyc2lvbiI6MTE4LCJyYW5rIjowLCJyYW5rX2lkIjoiMCA6IDE3Mi4zMS4z + My4zMCA6IDMyNzc0MDYiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmci + LCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQy + MTA5MDYiLCJwaWQiOjMyNzc0MDYsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVf + c3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGlu + Z19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1l + IjoiMzAwLTMwMy11MzAtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzAiLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiXSwiZ3B1X2luZGV4Ijow + LCJncHVfaW5kaWNlcyI6WzBdfSx7InZlcnNpb24iOjEwMiwicmFuayI6MSwicmFua19pZCI6IjEg + OiAxNzIuMzEuMzMuMzAgOiAzMjc4NTYwIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMi + OiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4x + LjIwMjQwMjE0MjEwOTA2IiwicGlkIjozMjc4NTYwLCJzdGFydF90aW1lIjoxNzA4NDQzNjU2LCJz + dGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIsInN0YXJ0X2NvdW50Ijox + LCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNl + LCJob3N0bmFtZSI6IjMwMC0zMDMtdTMwLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMwIiwi + Z3B1X2lkcyI6WyJHUFUtYTA3YzBlNDgtOTQ4YS00MDVjLTQzYjctNzM3NGQyZGRjMDhjIiwiR1BV + LTUzZTFiN2I0LTY4YjgtYTI4Yy0xMGYzLWRiNmEwNTk3ZmJiNCIsIkdQVS00MWZmOTFmYi1lY2I5 + LTBhNWItZDQ3Yy1kNWJiN2VmMTAzOGEiLCJHUFUtYTk0MGIxMjYtYjFhNC05ZjA3LTQ0ZTEtNjM2 + YzM3OTg5ZWNmIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJz + aW9uIjoxMDIsInJhbmsiOjIsInJhbmtfaWQiOiIyIDogMTcyLjMxLjMzLjMxIDogMTU0NDUxOSIs + InJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVz + Ijoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTU0 + NDUxOSwic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIw + IDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5l + d19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMS12 + MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMSIsImdwdV9pZHMiOlsiR1BVLTEzMmYxZGRiLWE1 + ZjQtMjBkMy0xMTIyLTZkMzU5OWFmY2YxZCIsIkdQVS0zYmM3YmZjZC05NWE5LWE2MjYtOGU4Zi0z + N2I5NzE5YWE5ZGQiLCJHUFUtZmUxMGFkM2QtODgzZC1hNTkwLWQ0MDUtZTBhNTY5M2IwYWYwIiwi + R1BVLTZiODI5Njk5LTBiNGMtMTJmMC0wYzI4LThjZjQ2YzI0YzE4NSJdLCJncHVfaW5kZXgiOjAs + ImdwdV9pbmRpY2VzIjpbMCwxLDIsM119LHsidmVyc2lvbiI6MTAwLCJyYW5rIjozLCJyYW5rX2lk + IjoiMyA6IDE3Mi4zMS4zMy4zMiA6IDE0Mjk2ODUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0 + YXR1cyI6InJ1bm5pbmciLCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6Ijcu + Mi4wLjEuMjAyNDAyMTQyMTA5MDYiLCJwaWQiOjE0Mjk2ODUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2 + NTYsInN0YXJ0X3RpbWVfc3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291 + bnQiOjEsImFjY2VwdGluZ19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6 + ZmFsc2UsImhvc3RuYW1lIjoiMzAwLTMwMy11MzItdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzIiLCJncHVfaWRzIjpbIkdQVS0wOTBjNDQzMC1kYmJlLTFlMWEtN2Y3Zi1hMTgyNzgzYWQyMzEi + LCJHUFUtYmUxNGI1Y2UtYjQxMS00OGNhLWE5ZmYtNWEwNmM3YTZmMzk4IiwiR1BVLTRiMWE1Njg4 + LTBlOGMtY2M5NC04MzNiLWMyZjM5ZTk5NTNiOCIsIkdQVS0xMmViYTQ2My04MzJlLTEwOGItZWNi + Mi01YzlhZjhkYTYxNjQiXSwiZ3B1X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7 + InZlcnNpb24iOjExNiwicmFuayI6NCwicmFua19pZCI6IjQgOiAxNzIuMzEuMzMuMzMgOiAxNjA4 + NzYxIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9z + dGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlk + IjoxNjA4NzYxLCJzdGFydF90aW1lIjoxNzA4NDQzNjU1LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBG + ZWIgMjAgMTU6NDA6NTUgMjAyNCIsInN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1 + ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMt + dTMzLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMzIiwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImdwdV9pbmRl + eCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjUsInJh + bmtfaWQiOiI1IDogMTcyLjMxLjMzLjM0IDogMTY2MDEwMiIsInJhbmtfbW9kZSI6InJ1biIsInJh + bmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9u + IjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTY2MDEwMiwic3RhcnRfdGltZSI6MTcw + ODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFy + dF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9v + bmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNC12MTAwIiwiaG9zdF9pZCI6IjE3Mi4z + MS4zMy4zNCIsImdwdV9pZHMiOlsiR1BVLTY4ZTA5Y2ZjLWY5YTQtMmExNC01N2E0LTk0ODNiOTFj + MmQ5YSIsIkdQVS0zZGYyMTZlOC1mZTc0LTA0N2EtOTVhYy03MmUyY2JlY2I1MjIiLCJHUFUtMTRk + NDRiOTgtYjA0Mi1jYjgxLTFkZDMtMjBkNGY2OWM4OWNhIiwiR1BVLTM0MDY3MzBiLWJlYWQtYzUw + YS00NmViLWUwYTJjMmJmNmU3NiJdLCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIs + M119LHsidmVyc2lvbiI6MTAyLCJyYW5rIjo2LCJyYW5rX2lkIjoiNiA6IDE3Mi4zMS4zMy4zNSA6 + IDEzNzk3MTUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmciLCJyZW1v + dmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQyMTA5MDYi + LCJwaWQiOjEzNzk3MTUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVfc3RyIjoi + VHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGluZ19qb2Jz + Ijp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzUtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzUiLCJncHVfaWRzIjpbIkdQVS1m + NzMwMmFiYy05ZWFhLTE0YzktZjQyNi0xNjNkZjNkYThjMjYiLCJHUFUtNzdkZDdkNDgtZjk4MC1m + ZDA2LTcyMmMtMWM1YjkzMjE4MjAzIiwiR1BVLTU1MmIyMGE1LTU3ZTYtNDk4Ni1iZTJiLTJiMzc4 + ZmQ0YmNhYSIsIkdQVS02MzA1MzE2Mi0zMDdmLTU1YzUtYTk3NC01OGRmZTg0MzQyYjIiXSwiZ3B1 + X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7InZlcnNpb24iOjEwMiwicmFuayI6 + NywicmFua19pZCI6IjcgOiAxNzIuMzEuMzMuMzYgOiAxMzc5NTM5IiwicmFua19tb2RlIjoicnVu + IiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3Zl + cnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlkIjoxMzc5NTM5LCJzdGFydF90aW1l + IjoxNzA4NDQzNjU2LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIs + InN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJy + ZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMtdTM2LXYxMDAiLCJob3N0X2lkIjoi + MTcyLjMxLjMzLjM2IiwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04MmYwLTNmZTQtZjFm + MmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZkMDA1N2FiOCIsIkdQ + VS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUtYWI3NTRhM2MtNjA4 + Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlsw + LDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjgsInJhbmtfaWQiOiI4IDogMTcyLjMxLjMz + LjM3IDogMTM5Nzg5MyIsInJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIs + InJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIx + MDkwNiIsInBpZCI6MTM5Nzg5Mywic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9z + dHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5n + X2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUi + OiIzMDAtMzAzLXUzNy12MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNyIsImdwdV9pZHMiOlsi + R1BVLWVhMThkMzg4LWUyYjMtNDI4My1hNmI1LWEzMjNhNDg3MjVhOSIsIkdQVS1kY2Q4NGVmYi05 + NGNhLWI0OTctOGMxNS03YTMyNjk0MGMxZWIiLCJHUFUtOTE2MDFhNWUtOTczZi1kMWU0LTZlMWQt + ZjY1NTI5NGQzNDYwIiwiR1BVLTA3ZmE0ZGI2LTllNTUtYjYxZi05MDlhLTg1YzRkMWJlYjA4OCJd + LCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIsM119XX0Oc3ltYm9scxZ7ImNvdW50 + IjoxfQxzeXN0ZW2qA3siaWQiOiJLaW5ldGljYSAzMDAtMzAzLXUzMC12MTAwIiwic3RhcnRfdGlt + ZSI6MTcwODEwMzQ1Miwic3RhdHVzIjoicnVubmluZyIsImNsdXN0ZXJfbGVhZGVyIjoiMTcyLjMx + LjMzLjMwIiwidmVyc2lvbiI6MjUsImNsdXN0ZXJfb3BlcmF0aW9uX3J1bm5pbmciOiJmYWxzZSIs + ImNsdXN0ZXJfb3BlcmF0aW9uX3N0YXR1cyI6IiIsIm9mZmxpbmVfc3RhdHVzIjoiZmFsc2UifQh0 + ZXh03AV7ImNvdW50Ijo4LCJzdGF0dXMiOlt7InZlcnNpb24iOjMzLCJyYW5rIjoxLCJzdGF0dXMi + OiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6Miwic3RhdHVzIjoicnVubmluZyJ9LHsi + dmVyc2lvbiI6MzMsInJhbmsiOjMsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24iOjMzLCJy + YW5rIjo0LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6NSwic3RhdHVz + IjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzMsInJhbmsiOjYsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjMzLCJyYW5rIjo3LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywi + cmFuayI6OCwic3RhdHVzIjoicnVubmluZyJ9XX0QdHJpZ2dlcnNeeyJ0b3RhbF9jb3VudCI6MCwi + cmFuZ2VfY291bnQiOjAsIm5haV9jb3VudCI6MH0AAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00056' + status: + code: 200 + message: OK +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/properties + response: + body: + string: !!binary | + BE9LAD5zaG93X3N5c3RlbV9wcm9wZXJ0aWVzX3Jlc3BvbnNlvPUCpAk8Y29uZi5haS5hcGkuY29u + bmVjdGlvbl90aW1lb3V0BDkwHmNvbmYuYWkuYXBpLmtleQAoY29uZi5haS5hcGkucHJvdmlkZXIW + a2luZXRpY2FsbG0eY29uZi5haS5hcGkudXJsSGh0dHA6Ly8xNzIuMzEuMzEuMTM6ODA1MC9zcWwv + c3VnZ2VzdDBjb25mLmFsZXJ0X2Rpc2tfYWJzb2x1dGUANGNvbmYuYWxlcnRfZGlza19wZXJjZW50 + YWdlGDEsIDUsIDEwLCAyMBxjb25mLmFsZXJ0X2V4ZQAsY29uZi5hbGVydF9ob3N0X3N0YXR1cwhU + UlVFOmNvbmYuYWxlcnRfaG9zdF9zdGF0dXNfZmlsdGVyIGZhdGFsX2luaXRfZXJyb3I4Y29uZi5h + bGVydF9tYXhfc3RvcmVkX2FsZXJ0cwYxMDA0Y29uZi5hbGVydF9tZW1vcnlfYWJzb2x1dGUAOGNv + bmYuYWxlcnRfbWVtb3J5X3BlcmNlbnRhZ2UYMSwgNSwgMTAsIDIwNGNvbmYuYWxlcnRfcmFua19j + dWRhX2Vycm9yCFRSVUVEY29uZi5hbGVydF9yYW5rX2ZhbGxiYWNrX2FsbG9jYXRvcghUUlVFLGNv + bmYuYWxlcnRfcmFua19zdGF0dXMIVFJVRTpjb25mLmFsZXJ0X3Jhbmtfc3RhdHVzX2ZpbHRlclhm + YXRhbF9pbml0X2Vycm9yLCBub3RfcmVzcG9uZGluZywgdGVybWluYXRlZB5jb25mLmF1ZGl0X2Jv + ZHkKRkFMU0UeY29uZi5hdWRpdF9kYXRhCkZBTFNFJGNvbmYuYXVkaXRfaGVhZGVycwpGQUxTRT5j + b25mLmF1dG9fY3JlYXRlX2V4dGVybmFsX3VzZXJzCkZBTFNFTGNvbmYuYnVpbGRfbWF0ZXJpYWxp + emVkX3ZpZXdzX29uX3N0YXJ0Em9uX2RlbWFuZDhjb25mLmJ1aWxkX3BrX2luZGV4X29uX3N0YXJ0 + Em9uX2RlbWFuZDhjb25mLmNodW5rX2NvbHVtbl9tYXhfbWVtb3J5EjUxMjAwMDAwMCpjb25mLmNo + dW5rX21heF9tZW1vcnkUODE5MjAwMDAwMB5jb25mLmNodW5rX3NpemUOODAwMDAwMCJjb25mLmNs + dXN0ZXJfbmFtZRxwcm9kdWN0aW9uLW5ld0Bjb25mLmNvbmN1cnJlbnRfa2VybmVsX2V4ZWN1dGlv + bghUUlVFOmNvbmYuZGVmYXVsdF9wcmltYXJ5X2tleV90eXBlDG1lbW9yeSBjb25mLmRlZmF1bHRf + dHRsBDIwLGNvbmYuZGlzYWJsZV9jbGVhcl9hbGwIVFJVRT5jb25mLmVncmVzc19wYXJxdWV0X2Nv + bXByZXNzaW9uDHNuYXBweSRjb25mLmVuYWJsZV9hbGVydHMIVFJVRSJjb25mLmVuYWJsZV9hdWRp + dApGQUxTRTJjb25mLmVuYWJsZV9hdXRob3JpemF0aW9uCFRSVUVGY29uZi5lbmFibGVfZXh0ZXJu + YWxfYXV0aGVudGljYXRpb24KRkFMU0UwY29uZi5lbmFibGVfZ3JhcGhfc2VydmVyCFRSVUUcY29u + Zi5lbmFibGVfaGEKRkFMU0UuY29uZi5lbmFibGVfaHR0cGRfcHJveHkKRkFMU0UcY29uZi5lbmFi + bGVfbWwKRkFMU0U2Y29uZi5lbmFibGVfb3BlbmdsX3JlbmRlcmVyCFRSVUVAY29uZi5lbmFibGVf + b3ZlcmxhcHBlZF9lcXVpX2pvaW4IVFJVRTRjb25mLmVuYWJsZV9wb3N0Z3Jlc19wcm94eQhUUlVF + PmNvbmYuZW5hYmxlX3ByZWRpY2F0ZV9lcXVpX2pvaW4IVFJVRSJjb25mLmVuYWJsZV9wcm9jcwhU + UlVFJGNvbmYuZW5hYmxlX3JldmVhbAhUUlVFMGNvbmYuZW5hYmxlX3N0YXRzX3NlcnZlcghUUlVF + LmNvbmYuZW5hYmxlX3RleHRfc2VhcmNoCFRSVUU8Y29uZi5lbmFibGVfdmVjdG9ydGlsZV9zZXJ2 + aWNlCFRSVUUsY29uZi5lbmFibGVfdnJhbV9jYWNoZQhUUlVFPmNvbmYuZW5hYmxlX3dvcmtlcl9o + dHRwX3NlcnZlcnMIVFJVRTJjb25mLmV2ZW50X3NlcnZlcl9hZGRyZXNzGDE3Mi4zMS4zMy4zMDRj + b25mLmV2ZW50X3NlcnZlcl9pbnRlcm5hbApGQUxTRTpjb25mLmV4dGVybmFsX2ZpbGVzX2RpcmVj + dG9yeSAvbmZzL2RhdGEvcHVibGljFGNvbmYuZ21faXAYMTcyLjMxLjMzLjMwGmNvbmYuZ21fcG9y + dDEINTU1MiBjb25mLmdtX3B1Yl9wb3J0CDU1NTMoY29uZi5ncmFwaC5oZWFkX3BvcnQIODEwMC5j + b25mLmdyYXBoLnNlcnZlcjAuaG9zdApob3N0MC5jb25mLmdyYXBoLnNlcnZlcjAucG9ydAg4MTAx + OGNvbmYuZ3JhcGguc2VydmVyMC5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjEuaG9zdApo + b3N0MS5jb25mLmdyYXBoLnNlcnZlcjEucG9ydAg4MTAyOGNvbmYuZ3JhcGguc2VydmVyMS5yYW1f + bGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjIuaG9zdApob3N0Mi5jb25mLmdyYXBoLnNlcnZlcjIu + cG9ydAg4MTAzOGNvbmYuZ3JhcGguc2VydmVyMi5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZl + cjMuaG9zdApob3N0My5jb25mLmdyYXBoLnNlcnZlcjMucG9ydAg4MTA0OGNvbmYuZ3JhcGguc2Vy + dmVyMy5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjQuaG9zdApob3N0NC5jb25mLmdyYXBo + LnNlcnZlcjQucG9ydAg4MTA1OGNvbmYuZ3JhcGguc2VydmVyNC5yYW1fbGltaXQCMC5jb25mLmdy + YXBoLnNlcnZlcjUuaG9zdApob3N0NS5jb25mLmdyYXBoLnNlcnZlcjUucG9ydAg4MTA2OGNvbmYu + Z3JhcGguc2VydmVyNS5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjYuaG9zdApob3N0Ni5j + b25mLmdyYXBoLnNlcnZlcjYucG9ydAg4MTA3OGNvbmYuZ3JhcGguc2VydmVyNi5yYW1fbGltaXQC + MC5jb25mLmdyYXBoLnNlcnZlcjcuaG9zdApob3N0Ny5jb25mLmdyYXBoLnNlcnZlcjcucG9ydAg4 + MTA4OGNvbmYuZ3JhcGguc2VydmVyNy5yYW1fbGltaXQCMBxjb25mLmhhX3F1ZXVlcwAuY29uZi5o + YV9yaW5nX2hlYWRfbm9kZXMAKGNvbmYuaGVhZF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zMBxjb25m + LmhlYWRfcG9ydAg5MTkxImNvbmYuaG1faHR0cF9wb3J0CDkzMDA2Y29uZi5ob3N0MF9hY2NlcHRz + X2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDBfYWRkcmVzcxgxNzIuMzEuMzMuMzAeY29uZi5ob3N0 + MF9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8v + MTcyLjMxLjMzLjMwOjkzMDAsY29uZi5ob3N0MF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMz + LjMwMmNvbmYuaG9zdDBfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMwLGNvbmYuaG9zdDBfcHVi + bGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMChjb25mLmhvc3QwX3JhbV9saW1pdBg2NTY3Njc3 + OTk5OTk2Y29uZi5ob3N0MV9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDFfYWRkcmVz + cxgxNzIuMzEuMzMuMzEeY29uZi5ob3N0MV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MV9ob3N0X21h + bmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMxOjkzMDAsY29uZi5ob3N0MV9wcml2 + YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMxMmNvbmYuaG9zdDFfcHVibGljX2FkZHJlc3MYMTcy + LjMxLjMzLjMxLGNvbmYuaG9zdDFfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMShjb25m + Lmhvc3QxX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0Ml9hY2NlcHRzX2ZhaWxvdmVy + CkZBTFNFJGNvbmYuaG9zdDJfYWRkcmVzcxgxNzIuMzEuMzMuMzIeY29uZi5ob3N0Ml9ncHVzDjAs + MSwyLDNEY29uZi5ob3N0Ml9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMz + LjMyOjkzMDAsY29uZi5ob3N0Ml9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMyMmNvbmYu + aG9zdDJfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMyLGNvbmYuaG9zdDJfcHVibGljX3VybHMm + aHR0cDovLzE3Mi4zMS4zMy4zMihjb25mLmhvc3QyX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29u + Zi5ob3N0M19hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDNfYWRkcmVzcxgxNzIuMzEu + MzMuMzMeY29uZi5ob3N0M19ncHVzDjAsMSwyLDNEY29uZi5ob3N0M19ob3N0X21hbmFnZXJfcHVi + bGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMzOjkzMDAsY29uZi5ob3N0M19wcml2YXRlX3VybCZo + dHRwOi8vMTcyLjMxLjMzLjMzMmNvbmYuaG9zdDNfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMz + LGNvbmYuaG9zdDNfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMyhjb25mLmhvc3QzX3Jh + bV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NF9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNv + bmYuaG9zdDRfYWRkcmVzcxgxNzIuMzEuMzMuMzQeY29uZi5ob3N0NF9ncHVzDjAsMSwyLDNEY29u + Zi5ob3N0NF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM0OjkzMDAs + Y29uZi5ob3N0NF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM0MmNvbmYuaG9zdDRfcHVi + bGljX2FkZHJlc3MYMTcyLjMxLjMzLjM0LGNvbmYuaG9zdDRfcHVibGljX3VybHMmaHR0cDovLzE3 + Mi4zMS4zMy4zNChjb25mLmhvc3Q0X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NV9h + Y2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDVfYWRkcmVzcxgxNzIuMzEuMzMuMzUeY29u + Zi5ob3N0NV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0NV9ob3N0X21hbmFnZXJfcHVibGljX3VybDBo + dHRwOi8vMTcyLjMxLjMzLjM1OjkzMDAsY29uZi5ob3N0NV9wcml2YXRlX3VybCZodHRwOi8vMTcy + LjMxLjMzLjM1MmNvbmYuaG9zdDVfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM1LGNvbmYuaG9z + dDVfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNShjb25mLmhvc3Q1X3JhbV9saW1pdBg2 + NTY3Njc3OTk5OTk2Y29uZi5ob3N0Nl9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDZf + YWRkcmVzcxgxNzIuMzEuMzMuMzYeY29uZi5ob3N0Nl9ncHVzDjAsMSwyLDNEY29uZi5ob3N0Nl9o + b3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM2OjkzMDAsY29uZi5ob3N0 + Nl9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM2MmNvbmYuaG9zdDZfcHVibGljX2FkZHJl + c3MYMTcyLjMxLjMzLjM2LGNvbmYuaG9zdDZfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4z + Nihjb25mLmhvc3Q2X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0N19hY2NlcHRzX2Zh + aWxvdmVyCkZBTFNFJGNvbmYuaG9zdDdfYWRkcmVzcxgxNzIuMzEuMzMuMzceY29uZi5ob3N0N19n + cHVzDjAsMSwyLDNEY29uZi5ob3N0N19ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcy + LjMxLjMzLjM3OjkzMDAsY29uZi5ob3N0N19wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM3 + MmNvbmYuaG9zdDdfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM3LGNvbmYuaG9zdDdfcHVibGlj + X3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNyhjb25mLmhvc3Q3X3JhbV9saW1pdBg2NTY3Njc3OTk5 + OTkqY29uZi5odHRwZF9wcm94eV9wb3J0CDgwODI0Y29uZi5odHRwZF9wcm94eV91c2VfaHR0cHMK + RkFMU0U4Y29uZi5pbml0X3dpdGhfbm93X2F0X3dvcmtlcgpGQUxTRSpjb25mLmthZmthLmJhdGNo + X3NpemUIMTAwMC5jb25mLmthZmthLnBvbGxfdGltZW91dAIwKGNvbmYua2Fma2Eud2FpdF90aW1l + BDMwLmNvbmYua2VybmVsX29tcF90aHJlYWRzAjQ0Y29uZi5sb2FkX3ZlY3RvcnNfb25fc3RhcnQS + b25fZGVtYW5kHmNvbmYubG9ja19hdWRpdApGQUxTRTZjb25mLm1heF9hdXRvX3ZpZXdfdXBkYXRv + cnMCMzZjb25mLm1heF9jb25jdXJyZW50X2tlcm5lbHMCMDJjb25mLm1heF9nZXRfcmVjb3Jkc19z + aXplCjIwMDAwKmNvbmYubWF4X2hlYXRtYXBfc2l6ZQgzMDcyKmNvbmYubWF4X2h0dHBfdGhyZWFk + cwY1MTI6Y29uZi5tZXRhZGF0YV9zdG9yZV9zeW5jX21vZGUMbm9ybWFsKmNvbmYubWluX2h0dHBf + dGhyZWFkcwI4MGNvbmYubWluX3Bhc3N3b3JkX2xlbmd0aAIwIGNvbmYubWxfYXBpX3BvcnQIOTE4 + N1xjb25mLm5wMS5idWlsZF9tYXRlcmlhbGl6ZWRfdmlld3Nfb25fbWlncmF0aW9uDGFsd2F5c0hj + b25mLm5wMS5idWlsZF9wa19pbmRleF9vbl9taWdyYXRpb24MYWx3YXlzRGNvbmYubnAxLmNyaXRp + Y2FsX3Jlc3RhcnRfYXR0ZW1wdHMCMTpjb25mLm5wMS5lbmFibGVfaGVhZF9mYWlsb3ZlcgpGQUxT + RT5jb25mLm5wMS5lbmFibGVfd29ya2VyX2ZhaWxvdmVyCkZBTFNFSmNvbmYubnAxLmZhaWxvdmVy + X2Rpc3RyaWJ1dGlvbl9wb2xpY3kIZmlsbERjb25mLm5wMS5sb2FkX3ZlY3RvcnNfb25fbWlncmF0 + aW9uDGFsd2F5c0xjb25mLm5wMS5ub25fY3JpdGljYWxfcmVzdGFydF9hdHRlbXB0cwIzPGNvbmYu + bnAxLnJhbmtfcmVzdGFydF9hdHRlbXB0cwIxMmNvbmYubnAxLnJlc3RhcnRfaW50ZXJ2YWwENjA2 + Y29uZi5ucDEuc3RvcmFnZV9hcGlfc2NyaXB0AChjb25mLm51bWJlcl9vZl9ob3N0cwI4KGNvbmYu + bnVtYmVyX29mX3JhbmtzAjk8Y29uZi5vcGVuZ2xfYW50aWFsaWFzaW5nX2xldmVsAjAsY29uZi5w + ZXJzaXN0X2RpcmVjdG9yeTAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8sY29uZi5wZXJzaXN0X3N5 + bmNfdGltZQI1NmNvbmYucG9pbnRfcmVuZGVyX3RocmVzaG9sZAwxMDAwMDBWY29uZi5wb3N0Z3Jl + c19wcm94eS5pZGxlX2Nvbm5lY3Rpb25fdGltZW91dAYzMDBUY29uZi5wb3N0Z3Jlc19wcm94eS5t + YXhfcXVldWVkX2Nvbm5lY3Rpb25zAjE+Y29uZi5wb3N0Z3Jlc19wcm94eS5tYXhfdGhyZWFkcwQ2 + ND5jb25mLnBvc3RncmVzX3Byb3h5Lm1pbl90aHJlYWRzAjIwY29uZi5wb3N0Z3Jlc19wcm94eS5w + b3J0CDU0MzIuY29uZi5wb3N0Z3Jlc19wcm94eS5zc2wIVFJVRRxjb25mLnJhbmswX2dwdQIwKmNv + bmYucmFuazBfaXBfYWRkcmVzcxgxNzIuMzEuMzMuMzAqY29uZi5yYW5rMV9pcF9hZGRyZXNzGDE3 + Mi4zMS4zMy4zMCpjb25mLnJhbmsyX2lwX2FkZHJlc3MYMTcyLjMxLjMzLjMxKmNvbmYucmFuazNf + aXBfYWRkcmVzcxgxNzIuMzEuMzMuMzIqY29uZi5yYW5rNF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4z + Mypjb25mLnJhbms1X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM0KmNvbmYucmFuazZfaXBfYWRkcmVz + cxgxNzIuMzEuMzMuMzUqY29uZi5yYW5rN19pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zNipjb25mLnJh + bms4X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM3KGNvbmYucmVxdWVzdF90aW1lb3V0CDI0MDA2Y29u + Zi5yZXF1aXJlX2F1dGhlbnRpY2F0aW9uCFRSVUVeY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0 + Lm1heF9jcHVfY29uY3VycmVuY3kELTFaY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0Lm1heF90 + aWVyX3ByaW9yaXR5BDEwSmNvbmYucmVzb3VyY2VfZ3JvdXAuZGVmYXVsdC5yYW1fbGltaXQELTFa + Y29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0LnNjaGVkdWxlX3ByaW9yaXR5BDUwTGNvbmYucmVz + b3VyY2VfZ3JvdXAuZGVmYXVsdC52cmFtX2xpbWl0BC0xHGNvbmYucmluZ19uYW1lDmRlZmF1bHRW + Y29uZi5zZWN1cml0eS5leHRlcm5hbC5yYW5nZXIuY2FjaGVfbWludXRlcwQ2MFRjb25mLnNlY3Vy + aXR5LmV4dGVybmFsLnJhbmdlci5zZXJ2aWNlX25hbWUQa2luZXRpY2FCY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXIudXJsAGBjb25mLnNlY3VyaXR5LmV4dGVybmFsLnJhbmdlcl9hdXRob3Jp + emVyLmFkZHJlc3MyaXBjOi8vL3RtcC9ncHVkYi1yYW5nZXItMHRjb25mLnNlY3VyaXR5LmV4dGVy + bmFsLnJhbmdlcl9hdXRob3JpemVyLnJlbW90ZV9kZWJ1Z19wb3J0AjBgY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXJfYXV0aG9yaXplci50aW1lb3V0BjEyMCpjb25mLnNldF9tb25pdG9yX3Bv + cnQIOTAwMjZjb25mLnNldF9tb25pdG9yX3Byb3h5X3BvcnQIOTAwMzZjb25mLnNldF9tb25pdG9y + X3F1ZXVlX3NpemUIMTAwMChjb25mLnNoYWRvd19hZ2dfc2l6ZRI1MDAwMDAwMDAwY29uZi5zaGFk + b3dfY3ViZV9lbmFibGVkCFRSVUUuY29uZi5zaGFkb3dfZmlsdGVyX3NpemUSNTAwMDAwMDAwJmNv + bmYuc21fb21wX3RocmVhZHMCMiRjb25mLnNtc19kaXJlY3RvcnkwL21udC9kYXRhL2dwdWRiL3Bl + cnNpc3QvLmNvbmYuc21zX21heF9vcGVuX2ZpbGVzBjEyOEBjb25mLnNxbC5jb3N0X2Jhc2VkX29w + dGltaXphdGlvbgpGQUxTRTRjb25mLnNxbC5kaXN0cmlidXRlZF9qb2lucwhUUlVFPmNvbmYuc3Fs + LmRpc3RyaWJ1dGVkX29wZXJhdGlvbnMIVFJVRS5jb25mLnNxbC5lbmFibGVfcGxhbm5lcghUUlVF + NmNvbmYuc3FsLmZvcmNlX2JpbmFyeV9qb2lucwpGQUxTRTpjb25mLnNxbC5mb3JjZV9iaW5hcnlf + c2V0X29wcwpGQUxTRTZjb25mLnNxbC5tYXhfcGFyYWxsZWxfc3RlcHMCNEBjb25mLnNxbC5tYXhf + dmlld19uZXN0aW5nX2xldmVscwQxNjJjb25mLnNxbC5wYWdpbmdfdGFibGVfdHRsBDIwNmNvbmYu + c3FsLnBhcmFsbGVsX2V4ZWN1dGlvbghUUlVFMGNvbmYuc3FsLnBsYW5fY2FjaGVfc2l6ZQg0MDAw + MGNvbmYuc3FsLnBsYW5uZXIuYWRkcmVzcz5pcGM6Ly8vdG1wL2dwdWRiLXF1ZXJ5LWVuZ2luZS0w + NmNvbmYuc3FsLnBsYW5uZXIubWF4X21lbW9yeQg0MDk2NGNvbmYuc3FsLnBsYW5uZXIubWF4X3N0 + YWNrAjZEY29uZi5zcWwucGxhbm5lci5yZW1vdGVfZGVidWdfcG9ydAIwMGNvbmYuc3FsLnBsYW5u + ZXIudGltZW91dAYxMjA0Y29uZi5zcWwucmVzdWx0X2NhY2hlX3NpemUINDAwMDRjb25mLnNxbC5y + ZXN1bHRzLmNhY2hlX3R0bAQ2MDBjb25mLnNxbC5yZXN1bHRzLmNhY2hpbmcIVFJVRUBjb25mLnNx + bC5ydWxlX2Jhc2VkX29wdGltaXphdGlvbghUUlVFPGNvbmYuc3VidGFza19jb25jdXJyZW5jeV9s + aW1pdAI0PmNvbmYuc3ltYm9sb2d5X3JlbmRlcl90aHJlc2hvbGQKMTAwMDBQY29uZi5zeXN0ZW1f + bWV0YWRhdGEuc3RhdHNfYWdncl9yb3djb3VudAoxMDAwMEhjb25mLnN5c3RlbV9tZXRhZGF0YS5z + dGF0c19hZ2dyX3RpbWUCMVJjb25mLnN5c3RlbV9tZXRhZGF0YS5zdGF0c19yZXRlbnRpb25fZGF5 + cwQyMSZjb25mLnRhc2tjYWxjX2dwdS4xElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4yElsw + LDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4zElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS40 + ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS41ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dw + dS42ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS43ElswLDEsMiwzXSZjb25mLnRhc2tjYWxj + X2dwdS44ElswLDEsMiwzXSBjb25mLnRjc19wZXJfdG9tBDQwJmNvbmYudGVtcF9kaXJlY3RvcnkI + L3RtcDJjb25mLnRleHRfaW5kZXhfZGlyZWN0b3J5MC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0LzJj + b25mLnRleHRfaW5kaWNlc19wZXJfdG9tAjJMY29uZi50aWVyLmRpc2swLmRlZmF1bHQuaGlnaF93 + YXRlcm1hcmsEOTA6Y29uZi50aWVyLmRpc2swLmRlZmF1bHQubGltaXQYNjAwMDAwMDAwMDAwSmNv + bmYudGllci5kaXNrMC5kZWZhdWx0Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLmRpc2swLmRl + ZmF1bHQucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlYGNvbmYudGllci5k + aXNrMC5kZWZhdWx0LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlz + azAucmFuazAuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbmswLmxpbWl0GDYw + MDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazAubG93X3dhdGVybWFyawQ4MDRjb25mLnRp + ZXIuZGlzazAucmFuazAucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNv + bmYudGllci5kaXNrMC5yYW5rMC5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50 + aWVyLmRpc2swLnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rMS5s + aW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJhbmsxLmxvd193YXRlcm1hcmsEODA0 + Y29uZi50aWVyLmRpc2swLnJhbmsxLnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tj + YWNoZVxjb25mLnRpZXIuZGlzazAucmFuazEuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNF + SGNvbmYudGllci5kaXNrMC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAu + cmFuazIubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rMi5sb3dfd2F0ZXJt + YXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rMi5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0 + Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbmsyLnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0 + cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazMuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVy + LmRpc2swLnJhbmszLmxpbWl0GDYwMDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazMubG93 + X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazMucGF0aEQvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5yYW5rMy5zdG9yZV9wZXJzaXN0ZW50 + X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNv + bmYudGllci5kaXNrMC5yYW5rNC5saW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJh + bms0Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2swLnJhbms0LnBhdGhEL21udC9kYXRh + L2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIuZGlzazAucmFuazQuc3RvcmVfcGVy + c2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNrMC5yYW5rNS5oaWdoX3dhdGVybWFy + awQ5MDZjb25mLnRpZXIuZGlzazAucmFuazUubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5k + aXNrMC5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rNS5wYXRoRC9t + bnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbms1LnN0 + b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazYuaGlnaF93 + YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbms2LmxpbWl0GDYwMDAwMDAwMDAwMEZjb25m + LnRpZXIuZGlzazAucmFuazYubG93X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazYu + cGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5y + YW5rNi5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms3 + LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rNy5saW1pdBg2MDAwMDAwMDAw + MDBGY29uZi50aWVyLmRpc2swLnJhbms3Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2sw + LnJhbms3LnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIu + ZGlzazAucmFuazcuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNr + MC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAucmFuazgubGltaXQYNjAw + MDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGll + ci5kaXNrMC5yYW5rOC5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29u + Zi50aWVyLmRpc2swLnJhbms4LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRVBjb25mLnRp + ZXIuZ2xvYmFsLmNvbmN1cnJlbnRfd2FpdF90aW1lb3V0BjYwMGpjb25mLnRpZXIuZ2xvYmFsLmRl + ZmVyX2NhY2hlX29iamVjdF9ldmljdGlvbnNfdG9fZGlzawhUUlVFUGNvbmYudGllci5wZXJzaXN0 + LmRlZmF1bHQuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnBlcnNpc3QuZGVmYXVsdC5saW1p + dBo2NTAwMDAwMDAwMDAwTmNvbmYudGllci5wZXJzaXN0LmRlZmF1bHQubG93X3dhdGVybWFyawQ4 + MDxjb25mLnRpZXIucGVyc2lzdC5kZWZhdWx0LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3Qv + OmNvbmYudGllci5wZXJzaXN0LmdyYXBoMC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpj + b25mLnRpZXIucGVyc2lzdC5ncmFwaDEucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29u + Zi50aWVyLnBlcnNpc3QuZ3JhcGgyLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYu + dGllci5wZXJzaXN0LmdyYXBoMy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRp + ZXIucGVyc2lzdC5ncmFwaDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29uZi50aWVy + LnBlcnNpc3QuZ3JhcGg1LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYudGllci5w + ZXJzaXN0LmdyYXBoNi5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRpZXIucGVy + c2lzdC5ncmFwaDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNp + c3QucmFuazAuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazAubGltaXQa + NjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwOGNv + bmYudGllci5wZXJzaXN0LnJhbmswLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYu + dGllci5wZXJzaXN0LnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJh + bmsxLmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazEubG93X3dhdGVy + bWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rMS5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJz + aXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIu + cGVyc2lzdC5yYW5rMi5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbmsy + Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazIucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNpc3QucmFuazMuaGlnaF93YXRlcm1hcmsEOTA6 + Y29uZi50aWVyLnBlcnNpc3QucmFuazMubGltaXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVy + c2lzdC5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwOGNvbmYudGllci5wZXJzaXN0LnJhbmszLnBhdGgw + L21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYudGllci5wZXJzaXN0LnJhbms0LmhpZ2hfd2F0 + ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJhbms0LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29u + Zi50aWVyLnBlcnNpc3QucmFuazQubG93X3dhdGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5y + YW5rNC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5r + NS5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIucGVyc2lzdC5yYW5rNS5saW1pdBo2NTAwMDAw + MDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbms1Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVy + LnBlcnNpc3QucmFuazUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBl + cnNpc3QucmFuazYuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazYubGlt + aXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgw + OGNvbmYudGllci5wZXJzaXN0LnJhbms2LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNv + bmYudGllci5wZXJzaXN0LnJhbms3LmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0 + LnJhbms3LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazcubG93X3dh + dGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rNy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9w + ZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRp + ZXIucGVyc2lzdC5yYW5rOC5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJh + bms4Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazgucGF0aDAvbW50L2Rh + dGEvZ3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDEucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDIucGF0aDAvbW50L2RhdGEvZ3B1 + ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDMucGF0aDAvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVy + c2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lz + dC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDYucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84 + Y29uZi50aWVyLnBlcnNpc3QudGV4dDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84Y29u + Zi50aWVyLnBlcnNpc3QudGV4dDgucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9IY29uZi50 + aWVyLnJhbS5kZWZhdWx0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5yYW0uZGVmYXVsdC5s + aW1pdAQtMUZjb25mLnRpZXIucmFtLmRlZmF1bHQubG93X3dhdGVybWFyawQ4MERjb25mLnRpZXIu + cmFtLnJhbmswLmhpZ2hfd2F0ZXJtYXJrBDkwMmNvbmYudGllci5yYW0ucmFuazAubGltaXQWNzcy + NjY4MDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazEuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazIuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazMuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazQuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazUuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazYuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazcuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazguaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rOC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwXGNvbmYudGllci52 + cmFtLmRlZmF1bHQuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBKY29uZi50aWVyLnZyYW0uZGVm + YXVsdC5hbGxfZ3B1cy5saW1pdAQtMVpjb25mLnRpZXIudnJhbS5kZWZhdWx0LmFsbF9ncHVzLmxv + d193YXRlcm1hcmsEODBUY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUwLmhpZ2hfd2F0ZXJtYXJr + BDkwQmNvbmYudGllci52cmFtLmRlZmF1bHQuZ3B1MC5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5k + ZWZhdWx0LmdwdTAubG93X3dhdGVybWFyawQ4MFRjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTEu + aGlnaF93YXRlcm1hcmsEOTBCY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUxLmxpbWl0BC0xUmNv + bmYudGllci52cmFtLmRlZmF1bHQuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwVGNvbmYudGllci52cmFt + LmRlZmF1bHQuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MEJjb25mLnRpZXIudnJhbS5kZWZhdWx0Lmdw + dTIubGltaXQELTFSY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUyLmxvd193YXRlcm1hcmsEODBU + Y29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwQmNvbmYudGllci52 + cmFtLmRlZmF1bHQuZ3B1My5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTMubG93 + X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMC5HUFUwLmhpZ2hfd2F0ZXJtYXJrBDkw + PmNvbmYudGllci52cmFtLnJhbmswLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAu + R1BVMC5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmhpZ2hf + d2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYu + dGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazAuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUwLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rMC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsw + LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbmswLmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazAuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUyLmxvd193YXRl + cm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25m + LnRpZXIudnJhbS5yYW5rMC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTMu + bG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5HUFUwLmhpZ2hfd2F0ZXJtYXJr + BDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFu + azEuR1BVMC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLkdQVTEuaGlnaF93 + YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuR1BVMS5saW1pdAQtMU5jb25mLnRpZXIu + dnJhbS5yYW5rMS5HUFUxLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuR1BV + Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5HUFUyLmxpbWl0BC0xTmNv + bmYudGllci52cmFtLnJhbmsxLkdQVTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5y + YW5rMS5HUFUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTMubGlt + aXQELTFOY29uZi50aWVyLnZyYW0ucmFuazEuR1BVMy5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGll + ci52cmFtLnJhbmsxLmFsbF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJh + bmsxLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGllci52cmFtLnJhbmsxLmFsbF9ncHVzLmxvd193 + YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5j + b25mLnRpZXIudnJhbS5yYW5rMS5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsxLmdw + dTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5ncHUxLmhpZ2hfd2F0ZXJt + YXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0u + cmFuazEuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLmdwdTIuaGln + aF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuZ3B1Mi5saW1pdAQtMU5jb25mLnRp + ZXIudnJhbS5yYW5rMS5ncHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEu + Z3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5ncHUzLmxpbWl0BC0x + TmNvbmYudGllci52cmFtLnJhbmsxLmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJh + bS5yYW5rMi5hbGxfZ3B1cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rMi5h + bGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJhbS5yYW5rMi5hbGxfZ3B1cy5sb3dfd2F0ZXJt + YXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50 + aWVyLnZyYW0ucmFuazIuZ3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUwLmxv + d193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazIuZ3B1MS5oaWdoX3dhdGVybWFyawQ5 + MD5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsy + LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMi5ncHUyLmhpZ2hfd2F0 + ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsyLmdwdTIubGltaXQELTFOY29uZi50aWVyLnZy + YW0ucmFuazIuZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTMu + aGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazIuZ3B1My5saW1pdAQtMU5jb25m + LnRpZXIudnJhbS5yYW5rMi5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFu + azMuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dw + dXMubGltaXQELTFWY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4 + MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52 + cmFtLnJhbmszLmdwdTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1MC5sb3dfd2F0 + ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmszLmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29u + Zi50aWVyLnZyYW0ucmFuazMuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUx + Lmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1Mi5oaWdoX3dhdGVybWFy + awQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJh + bmszLmdwdTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUzLmhpZ2hf + d2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmszLmdwdTMubGltaXQELTFOY29uZi50aWVy + LnZyYW0ucmFuazMuZ3B1My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms0LmFs + bF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxp + bWl0BC0xVmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29u + Zi50aWVyLnZyYW0ucmFuazQuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5y + YW5rNC5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms0LmdwdTAubG93X3dhdGVybWFy + awQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGll + ci52cmFtLnJhbms0LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1MS5sb3df + d2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms0LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+ + Y29uZi50aWVyLnZyYW0ucmFuazQuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNC5n + cHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1My5oaWdoX3dhdGVy + bWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFt + LnJhbms0LmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1 + cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5saW1pdAQt + MVZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGll + ci52cmFtLnJhbms1LmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazUu + Z3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNS5ncHUwLmxvd193YXRlcm1hcmsEODBQ + Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJh + bS5yYW5rNS5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms1LmdwdTEubG93X3dhdGVy + bWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNS5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYu + dGllci52cmFtLnJhbms1LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazUuZ3B1Mi5s + b3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms1LmdwdTMuaGlnaF93YXRlcm1hcmsE + OTA+Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5r + NS5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMuaGln + aF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubGltaXQELTFWY29u + Zi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJh + bS5yYW5rNi5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms2LmdwdTAu + bGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1MC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYu + dGllci52cmFtLnJhbms2LmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFu + azYuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNi5ncHUxLmxvd193YXRlcm1hcmsE + ODBQY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIu + dnJhbS5yYW5rNi5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms2LmdwdTIubG93X3dh + dGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNi5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNv + bmYudGllci52cmFtLnJhbms2LmdwdTMubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1 + My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmhpZ2hfd2F0 + ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGll + ci52cmFtLnJhbms3LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFu + azcuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUwLmxpbWl0 + BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIu + dnJhbS5yYW5rNy5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms3Lmdw + dTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNv + bmYudGllci52cmFtLnJhbms3LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0u + cmFuazcuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUyLmxvd193YXRlcm1h + cmsEODBQY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRp + ZXIudnJhbS5yYW5rNy5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTMubG93 + X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5oaWdoX3dhdGVybWFy + awQ5MEZjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJh + bS5yYW5rOC5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms4Lmdw + dTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazguZ3B1MC5saW1pdAQtMU5j + b25mLnRpZXIudnJhbS5yYW5rOC5ncHUwLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazguZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUxLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbms4LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rOC5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms4 + LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazguZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbms4LmdwdTMuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazguZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUzLmxvd193YXRl + cm1hcmsEODA0Y29uZi50aWVyX3N0cmF0ZWd5LmRlZmF1bHRCVlJBTSAyLCBSQU0gNSwgRElTSzAg + NSwgUEVSU0lTVCA1YGNvbmYudGllcl9zdHJhdGVneS5wcmVkaWNhdGVfZXZhbHVhdGlvbl9pbnRl + cnZhbAQ2MCRjb25mLnRvbXNfcGVyX3JhbmsCMSBjb25mLnRwc19wZXJfdG9tBDQwImNvbmYudHJp + Z2dlcl9wb3J0CDkwMDE+Y29uZi51bmlmaWVkX3NlY3VyaXR5X25hbWVzcGFjZQpGQUxTRTpjb25m + LnVzZV9leHRlcm5hbF90ZXh0X3NlcnZlcghUUlVFHGNvbmYudXNlX2h0dHBzCkZBTFNFLGNvbmYu + dmlkZW9fZGVmYXVsdF90dGwELTEoY29uZi52aWRlb19tYXhfY291bnQELTEyY29uZi52aWRlb190 + ZW1wX2RpcmVjdG9yeSwvdG1wL2dwdWRiLXRlbXAtdmlkZW9zImNvbmYud2FsLmNoZWNrc3VtCFRS + VUUwY29uZi53YWwuZmx1c2hfZnJlcXVlbmN5BDYwMmNvbmYud2FsLm1heF9zZWdtZW50X3NpemUS + NTAwMDAwMDAwLGNvbmYud2FsLnNlZ21lbnRfY291bnQELTEoY29uZi53YWwuc3luY19wb2xpY3kK + Zmx1c2g2Y29uZi53b3JrZXJfaHR0cF9zZXJ2ZXJfaXBz6AExNzIuMzEuMzMuMzA7MTcyLjMxLjMz + LjMwOzE3Mi4zMS4zMy4zMTsxNzIuMzEuMzMuMzI7MTcyLjMxLjMzLjMzOzE3Mi4zMS4zMy4zNDsx + NzIuMzEuMzMuMzU7MTcyLjMxLjMzLjM2OzE3Mi4zMS4zMy4zNzpjb25mLndvcmtlcl9odHRwX3Nl + cnZlcl9wb3J0c1g5MTkxOzkxOTI7OTE5Mzs5MTk0OzkxOTU7OTE5Njs5MTk3OzkxOTg7OTE5OThj + b25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzwANodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTE7aHR0 + cDovLzE3Mi4zMS4zMy4zMDo5MTkyO2h0dHA6Ly8xNzIuMzEuMzMuMzE6OTE5MztodHRwOi8vMTcy + LjMxLjMzLjMyOjkxOTQ7aHR0cDovLzE3Mi4zMS4zMy4zMzo5MTk1O2h0dHA6Ly8xNzIuMzEuMzMu + MzQ6OTE5NjtodHRwOi8vMTcyLjMxLjMzLjM1OjkxOTc7aHR0cDovLzE3Mi4zMS4zMy4zNjo5MTk4 + O2h0dHA6Ly8xNzIuMzEuMzMuMzc6OTE5OUhjb25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzX3By + aXZhdGXAA2h0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MTtodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTI7 + aHR0cDovLzE3Mi4zMS4zMy4zMTo5MTkzO2h0dHA6Ly8xNzIuMzEuMzMuMzI6OTE5NDtodHRwOi8v + MTcyLjMxLjMzLjMzOjkxOTU7aHR0cDovLzE3Mi4zMS4zMy4zNDo5MTk2O2h0dHA6Ly8xNzIuMzEu + MzMuMzU6OTE5NztodHRwOi8vMTcyLjMxLjMzLjM2OjkxOTg7aHR0cDovLzE3Mi4zMS4zMy4zNzo5 + MTk5KHN5c3RlbS5mb250X2ZhbWlsaWVzpgFEZWphVnUgTWF0aCBUZVggR3lyZSxEZWphVnUgU2Fu + cyBNb25vLERlamFWdSBTYW5zLERlamFWdSBTZXJpZixTYW5zLFNlcmlmLE1vbm9zcGFjZTB2ZXJz + aW9uLmdwdWRiX2J1aWxkX2RhdGUoRmViIDE0IDIwMjQgMjM6NDk6MDFAdmVyc2lvbi5ncHVkYl9j + b21wdXRlX2NhcGFiaWxpdHkWNjA7NzA7ODA7ODY4dmVyc2lvbi5ncHVkYl9jb21wdXRlX2VuZ2lu + ZQhDVURBPnZlcnNpb24uZ3B1ZGJfY29yZV9saWJzX3ZlcnNpb24UMjAyNDAyMTMwMDR2ZXJzaW9u + LmdwdWRiX2NvcmVfdmVyc2lvbiw3LjIuMC4xLjIwMjQwMjE0MjEwOTA2NHZlcnNpb24uZ3B1ZGJf + ZmlsZV92ZXJzaW9uFDIwMjEwMzExMjAqdmVyc2lvbi5ncHVkYl92ZXJzaW9uUDkyMjYwYTMyOWNh + NDVjYjBlMzc3NzZjZjkxNDQ5NzE3OWY2MjExNDM0dmVyc2lvbi5ncHVkYl92ZXJzaW9uX2RhdGUy + MjAyNC0wMi0xNCAyMTowOTowNiAtMDUwMCx2ZXJzaW9uLnB5dGhvbl92ZXJzaW9uDjMuMTAuMTMA + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00054' + status: + code: 200 + message: OK +- request: + body: !!binary | + hAFHRU5FUkFURSBQUk9NUFQgV0lUSCBPUFRJT05TIChDT05URVhUX05BTUVTID0gJ2RlbW8udGVz + dF9sbG1fY3R4JykAAgxiaW5hcnkAAAA= + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/execute/sql + response: + body: + string: !!binary | + BE9LAChleGVjdXRlX3NxbF9yZXNwb25zZe4MAPYDeyJuYW1lIjoiZ2VuZXJpY19yZXNwb25zZSIs + InR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJjb2x1bW5fMSIsInR5cGUiOnsidHlw + ZSI6ImFycmF5IiwiaXRlbXMiOiJzdHJpbmcifX0seyJuYW1lIjoiY29sdW1uX2hlYWRlcnMiLCJ0 + eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19LHsibmFtZSI6ImNvbHVtbl9k + YXRhdHlwZXMiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19XX2qBwL+ + BnsicGF5bG9hZCI6eyJjb250ZXh0IjpbeyJ0YWJsZSI6ImRlbW8udGVzdF9wcm9maWxlcyIsImNv + bHVtbnMiOlsidXNlcm5hbWUgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwibmFtZSBWQVJDSEFSICgz + MikgTk9UIE5VTEwiLCJzZXggVkFSQ0hBUiAoMSkgTk9UIE5VTEwiLCJhZGRyZXNzIFZBUkNIQVIg + KDY0KSBOT1QgTlVMTCIsIm1haWwgVkFSQ0hBUiAoMzIpIE5PVCBOVUxMIiwiYmlydGhkYXRlIFRJ + TUVTVEFNUCBOT1QgTlVMTCJdLCJkZXNjcmlwdGlvbiI6IkNvbnRhaW5zIHVzZXIgcHJvZmlsZXMu + IiwicnVsZXMiOltdfSx7InNhbXBsZXMiOnsiSG93IG1hbnkgbWFsZSB1c2VycyBhcmUgdGhlcmU/ + Ijoic2VsZWN0IGNvdW50KDEpIGFzIG51bV91c2Vyc1xuICAgICAgICAgICAgZnJvbSBkZW1vLnRl + c3RfcHJvZmlsZXNcbiAgICAgICAgICAgIHdoZXJlIHNleCA9ICcnTScnOyJ9fV19fQACDFByb21w + dAACDHN0cmluZwAAAgAACCBYLUtpbmV0aWNhLUdyb3VwBkRETApjb3VudAIwGmxhc3RfZW5kcG9p + bnQsL2dlbmVyYXRlL3NxbC9pbnRlcm5hbC50b3RhbF9udW1iZXJfb2ZfcmVjb3JkcwIwAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Kinetica-Group: + - DDL + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00806' + status: + code: 200 + message: OK +version: 1 diff --git a/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_setup.yaml b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_setup.yaml new file mode 100644 index 0000000000..e2a41164f7 --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/cassettes/TestChatKinetica.test_setup.yaml @@ -0,0 +1,1320 @@ +interactions: +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/status + response: + body: + string: !!binary | + BE9LADZzaG93X3N5c3RlbV9zdGF0dXNfcmVzcG9uc2X8ugEUCmdyYXBovAl7ImNvdW50Ijo4LCJz + dGF0dXMiOlt7InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjAsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzAiLCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjoxLCJob3N0 + X2lkIjoiMTcyLjMxLjMzLjMxIiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNl + cnZlcl9pZCI6MiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMiIsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjM5LCJzZXJ2ZXJfaWQiOjMsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzMiLCJzdGF0 + dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo0LCJob3N0X2lkIjoiMTcy + LjMxLjMzLjM0Iiwic3RhdHVzIjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzksInNlcnZlcl9pZCI6 + NSwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNSIsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24i + OjM5LCJzZXJ2ZXJfaWQiOjYsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzYiLCJzdGF0dXMiOiJydW5u + aW5nIn0seyJ2ZXJzaW9uIjozOSwic2VydmVyX2lkIjo3LCJob3N0X2lkIjoiMTcyLjMxLjMzLjM3 + Iiwic3RhdHVzIjoicnVubmluZyJ9XX0eaGFfY2x1c3Rlcl9pbmZvzAN7ImhhX3JhbmtzX2luZm8i + Olt7InByaXZhdGVfdXJsIjoiaHR0cDovLzE3Mi4zMS4zMy4zMDo5MTkxIiwicHVibGljX3VybCI6 + Imh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MSIsImhhX3VybF9vdmVycmlkZSI6Imh0dHA6Ly8xNzIu + MzEuMzMuMzA6OTE5MSIsImFsdGVybmF0ZV91cmxzIjpbImh0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5 + MSJdfV0sInJlYWR5Ijp0cnVlLCJuYW1lIjoicHJvZHVjdGlvbi1uZXcifQpob3N0c/hLeyJjb3Vu + dCI6OCwic3RhdHVzIjpbeyJ2ZXJzaW9uIjoxMzMsImhvc3RfbnVtYmVyIjowLCJpZCI6IjE3Mi4z + MS4zMy4zMCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzAtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmci + LCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9z + dGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoicnVubmluZyIsInJldmVh + bF9zdGF0dXMiOiJydW5uaW5nIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEyNjAwMzIsInN0YXJ0X3Rp + bWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4zMCJdLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiLCJHUFUtNTNlMWI3YjQt + NjhiOC1hMjhjLTEwZjMtZGI2YTA1OTdmYmI0IiwiR1BVLTQxZmY5MWZiLWVjYjktMGE1Yi1kNDdj + LWQ1YmI3ZWYxMDM4YSIsIkdQVS1hOTQwYjEyNi1iMWE0LTlmMDctNDRlMS02MzZjMzc5ODllY2Yi + XSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoibGVhZGVyIiwiaG9zdF90 + ZXJtIjowLCJob3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9u + IjoxMTMsImhvc3RfbnVtYmVyIjoxLCJpZCI6IjE3Mi4zMS4zMy4zMSIsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzEtdjEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxl + ZCIsInN0YXRzX3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5 + X3BsYW5uZXJfc3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90 + YWxfbWVtb3J5Ijo4MTAyMDEyMzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtf + aXBzIjpbIjE3Mi4zMS4zMy4zMSJdLCJncHVfaWRzIjpbIkdQVS0xMzJmMWRkYi1hNWY0LTIwZDMt + MTEyMi02ZDM1OTlhZmNmMWQiLCJHUFUtM2JjN2JmY2QtOTVhOS1hNjI2LThlOGYtMzdiOTcxOWFh + OWRkIiwiR1BVLWZlMTBhZDNkLTg4M2QtYTU5MC1kNDA1LWUwYTU2OTNiMGFmMCIsIkdQVS02Yjgy + OTY5OS0wYjRjLTEyZjAtMGMyOC04Y2Y0NmMyNGMxODUiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZh + bHNlIiwiaG9zdF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25f + c3RhdHVzIjoibGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjIs + ImlkIjoiMTcyLjMxLjMzLjMyIiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMi12MTAwIiwic3RhdHVz + IjoicnVubmluZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVu + bmluZyIsIm1sX3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9w + cGVkIiwicmV2ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTIzMTM2 + MCwic3RhcnRfdGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjMyIl0s + ImdwdV9pZHMiOlsiR1BVLTA5MGM0NDMwLWRiYmUtMWUxYS03ZjdmLWExODI3ODNhZDIzMSIsIkdQ + VS1iZTE0YjVjZS1iNDExLTQ4Y2EtYTlmZi01YTA2YzdhNmYzOTgiLCJHUFUtNGIxYTU2ODgtMGU4 + Yy1jYzk0LTgzM2ItYzJmMzllOTk1M2I4IiwiR1BVLTEyZWJhNDYzLTgzMmUtMTA4Yi1lY2IyLTVj + OWFmOGRhNjE2NCJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xs + b3dlciIsImhvc3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3Rl + ZCJ9LHsidmVyc2lvbiI6MTEzLCJob3N0X251bWJlciI6MywiaWQiOiIxNzIuMzEuMzMuMzMiLCJo + b3N0bmFtZSI6IjMwMC0zMDMtdTMzLXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3Rh + dHVzIjoiZGlzYWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlz + YWJsZWQiLCJxdWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoi + c3RvcHBlZCIsInRvdGFsX21lbW9yeSI6ODEwMjAxMjM5NTUyLCJzdGFydF90aW1lIjoxNzA4MTAz + NDUyLCJuZXR3b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzMiXSwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImFjY2VwdHNf + ZmFpbG92ZXIiOiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJo + b3N0X2VsZWN0aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhv + c3RfbnVtYmVyIjo0LCJpZCI6IjE3Mi4zMS4zMy4zNCIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzQt + djEwMCIsInN0YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRz + X3N0YXR1cyI6InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJf + c3RhdHVzIjoic3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5 + Ijo4MTAyMDEyMTA4ODAsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3 + Mi4zMS4zMy4zNCJdLCJncHVfaWRzIjpbIkdQVS02OGUwOWNmYy1mOWE0LTJhMTQtNTdhNC05NDgz + YjkxYzJkOWEiLCJHUFUtM2RmMjE2ZTgtZmU3NC0wNDdhLTk1YWMtNzJlMmNiZWNiNTIyIiwiR1BV + LTE0ZDQ0Yjk4LWIwNDItY2I4MS0xZGQzLTIwZDRmNjljODljYSIsIkdQVS0zNDA2NzMwYi1iZWFk + LWM1MGEtNDZlYi1lMGEyYzJiZjZlNzYiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9z + dF9yb2xlIjoiZm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoi + bGVhZGVyX2VsZWN0ZWQifSx7InZlcnNpb24iOjExMywiaG9zdF9udW1iZXIiOjUsImlkIjoiMTcy + LjMxLjMzLjM1IiwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNS12MTAwIiwic3RhdHVzIjoicnVubmlu + ZyIsImh0dHBkX3N0YXR1cyI6ImRpc2FibGVkIiwic3RhdHNfc3RhdHVzIjoicnVubmluZyIsIm1s + X3N0YXR1cyI6ImRpc2FibGVkIiwicXVlcnlfcGxhbm5lcl9zdGF0dXMiOiJzdG9wcGVkIiwicmV2 + ZWFsX3N0YXR1cyI6InN0b3BwZWQiLCJ0b3RhbF9tZW1vcnkiOjgxMDIwMTI0Nzc0NCwic3RhcnRf + dGltZSI6MTcwODEwMzQ1MiwibmV0d29ya19pcHMiOlsiMTcyLjMxLjMzLjM1Il0sImdwdV9pZHMi + OlsiR1BVLWY3MzAyYWJjLTllYWEtMTRjOS1mNDI2LTE2M2RmM2RhOGMyNiIsIkdQVS03N2RkN2Q0 + OC1mOTgwLWZkMDYtNzIyYy0xYzViOTMyMTgyMDMiLCJHUFUtNTUyYjIwYTUtNTdlNi00OTg2LWJl + MmItMmIzNzhmZDRiY2FhIiwiR1BVLTYzMDUzMTYyLTMwN2YtNTVjNS1hOTc0LTU4ZGZlODQzNDJi + MiJdLCJhY2NlcHRzX2ZhaWxvdmVyIjoiZmFsc2UiLCJob3N0X3JvbGUiOiJmb2xsb3dlciIsImhv + c3RfdGVybSI6MCwiaG9zdF9lbGVjdGlvbl9zdGF0dXMiOiJsZWFkZXJfZWxlY3RlZCJ9LHsidmVy + c2lvbiI6MTEzLCJob3N0X251bWJlciI6NiwiaWQiOiIxNzIuMzEuMzMuMzYiLCJob3N0bmFtZSI6 + IjMwMC0zMDMtdTM2LXYxMDAiLCJzdGF0dXMiOiJydW5uaW5nIiwiaHR0cGRfc3RhdHVzIjoiZGlz + YWJsZWQiLCJzdGF0c19zdGF0dXMiOiJydW5uaW5nIiwibWxfc3RhdHVzIjoiZGlzYWJsZWQiLCJx + dWVyeV9wbGFubmVyX3N0YXR1cyI6InN0b3BwZWQiLCJyZXZlYWxfc3RhdHVzIjoic3RvcHBlZCIs + InRvdGFsX21lbW9yeSI6ODEwMjAxMjIzMTY4LCJzdGFydF90aW1lIjoxNzA4MTAzNDUyLCJuZXR3 + b3JrX2lwcyI6WyIxNzIuMzEuMzMuMzYiXSwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04 + MmYwLTNmZTQtZjFmMmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZk + MDA1N2FiOCIsIkdQVS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUt + YWI3NTRhM2MtNjA4Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImFjY2VwdHNfZmFpbG92ZXIi + OiJmYWxzZSIsImhvc3Rfcm9sZSI6ImZvbGxvd2VyIiwiaG9zdF90ZXJtIjowLCJob3N0X2VsZWN0 + aW9uX3N0YXR1cyI6ImxlYWRlcl9lbGVjdGVkIn0seyJ2ZXJzaW9uIjoxMTMsImhvc3RfbnVtYmVy + Ijo3LCJpZCI6IjE3Mi4zMS4zMy4zNyIsImhvc3RuYW1lIjoiMzAwLTMwMy11MzctdjEwMCIsInN0 + YXR1cyI6InJ1bm5pbmciLCJodHRwZF9zdGF0dXMiOiJkaXNhYmxlZCIsInN0YXRzX3N0YXR1cyI6 + InJ1bm5pbmciLCJtbF9zdGF0dXMiOiJkaXNhYmxlZCIsInF1ZXJ5X3BsYW5uZXJfc3RhdHVzIjoi + c3RvcHBlZCIsInJldmVhbF9zdGF0dXMiOiJzdG9wcGVkIiwidG90YWxfbWVtb3J5Ijo4MTAyMDEy + MzU0NTYsInN0YXJ0X3RpbWUiOjE3MDgxMDM0NTIsIm5ldHdvcmtfaXBzIjpbIjE3Mi4zMS4zMy4z + NyJdLCJncHVfaWRzIjpbIkdQVS1lYTE4ZDM4OC1lMmIzLTQyODMtYTZiNS1hMzIzYTQ4NzI1YTki + LCJHUFUtZGNkODRlZmItOTRjYS1iNDk3LThjMTUtN2EzMjY5NDBjMWViIiwiR1BVLTkxNjAxYTVl + LTk3M2YtZDFlNC02ZTFkLWY2NTUyOTRkMzQ2MCIsIkdQVS0wN2ZhNGRiNi05ZTU1LWI2MWYtOTA5 + YS04NWM0ZDFiZWIwODgiXSwiYWNjZXB0c19mYWlsb3ZlciI6ImZhbHNlIiwiaG9zdF9yb2xlIjoi + Zm9sbG93ZXIiLCJob3N0X3Rlcm0iOjAsImhvc3RfZWxlY3Rpb25fc3RhdHVzIjoibGVhZGVyX2Vs + ZWN0ZWQifV19Fmh0dHBfc2VydmVyoAN7ImNvbm5lY3Rpb25zIjp7ImN1cnJlbnQiOjEsIm1heF9j + b25jdXJyZW50IjoxMTYsInF1ZXVlZCI6MCwibWF4X3F1ZXVlZF9hbGxvd2VkIjo2NTUzNiwidG90 + YWwiOjMyNTg4MiwicmVmdXNlZCI6MCwidGhyZWFkcyI6Mn0sInRocmVhZHMiOnsidXNlZCI6Miwi + Y2FwYWNpdHkiOjUxMiwiYWxsb2NhdGVkIjo4LCJhdmFpbGFibGUiOjUxMCwic3RhY2tfc2l6ZSI6 + MH19FG1pZ3JhdGlvbnMueyJjb3VudCI6MCwic3RhdHVzIjpbXX0KcmFua3PgUnsiY291bnQiOjks + InN0YXR1cyI6W3sidmVyc2lvbiI6MTE4LCJyYW5rIjowLCJyYW5rX2lkIjoiMCA6IDE3Mi4zMS4z + My4zMCA6IDMyNzc0MDYiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmci + LCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQy + MTA5MDYiLCJwaWQiOjMyNzc0MDYsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVf + c3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGlu + Z19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1l + IjoiMzAwLTMwMy11MzAtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzAiLCJncHVfaWRzIjpb + IkdQVS1hMDdjMGU0OC05NDhhLTQwNWMtNDNiNy03Mzc0ZDJkZGMwOGMiXSwiZ3B1X2luZGV4Ijow + LCJncHVfaW5kaWNlcyI6WzBdfSx7InZlcnNpb24iOjEwMiwicmFuayI6MSwicmFua19pZCI6IjEg + OiAxNzIuMzEuMzMuMzAgOiAzMjc4NTYwIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMi + OiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4x + LjIwMjQwMjE0MjEwOTA2IiwicGlkIjozMjc4NTYwLCJzdGFydF90aW1lIjoxNzA4NDQzNjU2LCJz + dGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIsInN0YXJ0X2NvdW50Ijox + LCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNl + LCJob3N0bmFtZSI6IjMwMC0zMDMtdTMwLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMwIiwi + Z3B1X2lkcyI6WyJHUFUtYTA3YzBlNDgtOTQ4YS00MDVjLTQzYjctNzM3NGQyZGRjMDhjIiwiR1BV + LTUzZTFiN2I0LTY4YjgtYTI4Yy0xMGYzLWRiNmEwNTk3ZmJiNCIsIkdQVS00MWZmOTFmYi1lY2I5 + LTBhNWItZDQ3Yy1kNWJiN2VmMTAzOGEiLCJHUFUtYTk0MGIxMjYtYjFhNC05ZjA3LTQ0ZTEtNjM2 + YzM3OTg5ZWNmIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJz + aW9uIjoxMDIsInJhbmsiOjIsInJhbmtfaWQiOiIyIDogMTcyLjMxLjMzLjMxIDogMTU0NDUxOSIs + InJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVz + Ijoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTU0 + NDUxOSwic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIw + IDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5l + d19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzMS12 + MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zMSIsImdwdV9pZHMiOlsiR1BVLTEzMmYxZGRiLWE1 + ZjQtMjBkMy0xMTIyLTZkMzU5OWFmY2YxZCIsIkdQVS0zYmM3YmZjZC05NWE5LWE2MjYtOGU4Zi0z + N2I5NzE5YWE5ZGQiLCJHUFUtZmUxMGFkM2QtODgzZC1hNTkwLWQ0MDUtZTBhNTY5M2IwYWYwIiwi + R1BVLTZiODI5Njk5LTBiNGMtMTJmMC0wYzI4LThjZjQ2YzI0YzE4NSJdLCJncHVfaW5kZXgiOjAs + ImdwdV9pbmRpY2VzIjpbMCwxLDIsM119LHsidmVyc2lvbiI6MTAwLCJyYW5rIjozLCJyYW5rX2lk + IjoiMyA6IDE3Mi4zMS4zMy4zMiA6IDE0Mjk2ODUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0 + YXR1cyI6InJ1bm5pbmciLCJyZW1vdmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6Ijcu + Mi4wLjEuMjAyNDAyMTQyMTA5MDYiLCJwaWQiOjE0Mjk2ODUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2 + NTYsInN0YXJ0X3RpbWVfc3RyIjoiVHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291 + bnQiOjEsImFjY2VwdGluZ19qb2JzIjp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6 + ZmFsc2UsImhvc3RuYW1lIjoiMzAwLTMwMy11MzItdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMu + MzIiLCJncHVfaWRzIjpbIkdQVS0wOTBjNDQzMC1kYmJlLTFlMWEtN2Y3Zi1hMTgyNzgzYWQyMzEi + LCJHUFUtYmUxNGI1Y2UtYjQxMS00OGNhLWE5ZmYtNWEwNmM3YTZmMzk4IiwiR1BVLTRiMWE1Njg4 + LTBlOGMtY2M5NC04MzNiLWMyZjM5ZTk5NTNiOCIsIkdQVS0xMmViYTQ2My04MzJlLTEwOGItZWNi + Mi01YzlhZjhkYTYxNjQiXSwiZ3B1X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7 + InZlcnNpb24iOjExNiwicmFuayI6NCwicmFua19pZCI6IjQgOiAxNzIuMzEuMzMuMzMgOiAxNjA4 + NzYxIiwicmFua19tb2RlIjoicnVuIiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9z + dGF0dXMiOiJub25lIiwiYXBwX3ZlcnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlk + IjoxNjA4NzYxLCJzdGFydF90aW1lIjoxNzA4NDQzNjU1LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBG + ZWIgMjAgMTU6NDA6NTUgMjAyNCIsInN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1 + ZSwibmV3X3JhbmsiOmZhbHNlLCJyZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMt + dTMzLXYxMDAiLCJob3N0X2lkIjoiMTcyLjMxLjMzLjMzIiwiZ3B1X2lkcyI6WyJHUFUtMjYzMzFh + MDctMTc1Ni1mMDY2LTFlNWEtMzc1M2Y1ZTViYzc4IiwiR1BVLWE0MWFhMTg3LTQ1NmQtNjBiMy04 + ZmM5LWI4YjMzZWFlMjFiYyIsIkdQVS01NWRlZjYxOS0wMTE2LWViZjctMzMwMy03ZDkzMmRmYzcw + ZmYiLCJHUFUtNGM5YWYzODgtYjlmYi03MWQ5LWZiNDUtODMwYTM4MTIwMGQzIl0sImdwdV9pbmRl + eCI6MCwiZ3B1X2luZGljZXMiOlswLDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjUsInJh + bmtfaWQiOiI1IDogMTcyLjMxLjMzLjM0IDogMTY2MDEwMiIsInJhbmtfbW9kZSI6InJ1biIsInJh + bmtfc3RhdHVzIjoicnVubmluZyIsInJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9u + IjoiNy4yLjAuMS4yMDI0MDIxNDIxMDkwNiIsInBpZCI6MTY2MDEwMiwic3RhcnRfdGltZSI6MTcw + ODQ0MzY1Niwic3RhcnRfdGltZV9zdHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFy + dF9jb3VudCI6MSwiYWNjZXB0aW5nX2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9v + bmx5IjpmYWxzZSwiaG9zdG5hbWUiOiIzMDAtMzAzLXUzNC12MTAwIiwiaG9zdF9pZCI6IjE3Mi4z + MS4zMy4zNCIsImdwdV9pZHMiOlsiR1BVLTY4ZTA5Y2ZjLWY5YTQtMmExNC01N2E0LTk0ODNiOTFj + MmQ5YSIsIkdQVS0zZGYyMTZlOC1mZTc0LTA0N2EtOTVhYy03MmUyY2JlY2I1MjIiLCJHUFUtMTRk + NDRiOTgtYjA0Mi1jYjgxLTFkZDMtMjBkNGY2OWM4OWNhIiwiR1BVLTM0MDY3MzBiLWJlYWQtYzUw + YS00NmViLWUwYTJjMmJmNmU3NiJdLCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIs + M119LHsidmVyc2lvbiI6MTAyLCJyYW5rIjo2LCJyYW5rX2lkIjoiNiA6IDE3Mi4zMS4zMy4zNSA6 + IDEzNzk3MTUiLCJyYW5rX21vZGUiOiJydW4iLCJyYW5rX3N0YXR1cyI6InJ1bm5pbmciLCJyZW1v + dmFsX3N0YXR1cyI6Im5vbmUiLCJhcHBfdmVyc2lvbiI6IjcuMi4wLjEuMjAyNDAyMTQyMTA5MDYi + LCJwaWQiOjEzNzk3MTUsInN0YXJ0X3RpbWUiOjE3MDg0NDM2NTYsInN0YXJ0X3RpbWVfc3RyIjoi + VHVlIEZlYiAyMCAxNTo0MDo1NiAyMDI0Iiwic3RhcnRfY291bnQiOjEsImFjY2VwdGluZ19qb2Jz + Ijp0cnVlLCJuZXdfcmFuayI6ZmFsc2UsInJlYWRfb25seSI6ZmFsc2UsImhvc3RuYW1lIjoiMzAw + LTMwMy11MzUtdjEwMCIsImhvc3RfaWQiOiIxNzIuMzEuMzMuMzUiLCJncHVfaWRzIjpbIkdQVS1m + NzMwMmFiYy05ZWFhLTE0YzktZjQyNi0xNjNkZjNkYThjMjYiLCJHUFUtNzdkZDdkNDgtZjk4MC1m + ZDA2LTcyMmMtMWM1YjkzMjE4MjAzIiwiR1BVLTU1MmIyMGE1LTU3ZTYtNDk4Ni1iZTJiLTJiMzc4 + ZmQ0YmNhYSIsIkdQVS02MzA1MzE2Mi0zMDdmLTU1YzUtYTk3NC01OGRmZTg0MzQyYjIiXSwiZ3B1 + X2luZGV4IjowLCJncHVfaW5kaWNlcyI6WzAsMSwyLDNdfSx7InZlcnNpb24iOjEwMiwicmFuayI6 + NywicmFua19pZCI6IjcgOiAxNzIuMzEuMzMuMzYgOiAxMzc5NTM5IiwicmFua19tb2RlIjoicnVu + IiwicmFua19zdGF0dXMiOiJydW5uaW5nIiwicmVtb3ZhbF9zdGF0dXMiOiJub25lIiwiYXBwX3Zl + cnNpb24iOiI3LjIuMC4xLjIwMjQwMjE0MjEwOTA2IiwicGlkIjoxMzc5NTM5LCJzdGFydF90aW1l + IjoxNzA4NDQzNjU2LCJzdGFydF90aW1lX3N0ciI6IlR1ZSBGZWIgMjAgMTU6NDA6NTYgMjAyNCIs + InN0YXJ0X2NvdW50IjoxLCJhY2NlcHRpbmdfam9icyI6dHJ1ZSwibmV3X3JhbmsiOmZhbHNlLCJy + ZWFkX29ubHkiOmZhbHNlLCJob3N0bmFtZSI6IjMwMC0zMDMtdTM2LXYxMDAiLCJob3N0X2lkIjoi + MTcyLjMxLjMzLjM2IiwiZ3B1X2lkcyI6WyJHUFUtOGU5ZDRhZGItYzYxMS04MmYwLTNmZTQtZjFm + MmMzZTZhNDRmIiwiR1BVLTRjNmFiYWM5LTc0ZWMtZjc4Yy1mYWE5LTQ3NDZkMDA1N2FiOCIsIkdQ + VS05NjI1YTc4Yy1lMmFlLTdmMDktOWNjZi1lZTA0OTk1MjYzMTAiLCJHUFUtYWI3NTRhM2MtNjA4 + Ni1iYjUxLWU5NGEtM2NmNGExNDkwNWJhIl0sImdwdV9pbmRleCI6MCwiZ3B1X2luZGljZXMiOlsw + LDEsMiwzXX0seyJ2ZXJzaW9uIjoxMDIsInJhbmsiOjgsInJhbmtfaWQiOiI4IDogMTcyLjMxLjMz + LjM3IDogMTM5Nzg5MyIsInJhbmtfbW9kZSI6InJ1biIsInJhbmtfc3RhdHVzIjoicnVubmluZyIs + InJlbW92YWxfc3RhdHVzIjoibm9uZSIsImFwcF92ZXJzaW9uIjoiNy4yLjAuMS4yMDI0MDIxNDIx + MDkwNiIsInBpZCI6MTM5Nzg5Mywic3RhcnRfdGltZSI6MTcwODQ0MzY1Niwic3RhcnRfdGltZV9z + dHIiOiJUdWUgRmViIDIwIDE1OjQwOjU2IDIwMjQiLCJzdGFydF9jb3VudCI6MSwiYWNjZXB0aW5n + X2pvYnMiOnRydWUsIm5ld19yYW5rIjpmYWxzZSwicmVhZF9vbmx5IjpmYWxzZSwiaG9zdG5hbWUi + OiIzMDAtMzAzLXUzNy12MTAwIiwiaG9zdF9pZCI6IjE3Mi4zMS4zMy4zNyIsImdwdV9pZHMiOlsi + R1BVLWVhMThkMzg4LWUyYjMtNDI4My1hNmI1LWEzMjNhNDg3MjVhOSIsIkdQVS1kY2Q4NGVmYi05 + NGNhLWI0OTctOGMxNS03YTMyNjk0MGMxZWIiLCJHUFUtOTE2MDFhNWUtOTczZi1kMWU0LTZlMWQt + ZjY1NTI5NGQzNDYwIiwiR1BVLTA3ZmE0ZGI2LTllNTUtYjYxZi05MDlhLTg1YzRkMWJlYjA4OCJd + LCJncHVfaW5kZXgiOjAsImdwdV9pbmRpY2VzIjpbMCwxLDIsM119XX0Oc3ltYm9scxZ7ImNvdW50 + IjoxfQxzeXN0ZW2qA3siaWQiOiJLaW5ldGljYSAzMDAtMzAzLXUzMC12MTAwIiwic3RhcnRfdGlt + ZSI6MTcwODEwMzQ1Miwic3RhdHVzIjoicnVubmluZyIsImNsdXN0ZXJfbGVhZGVyIjoiMTcyLjMx + LjMzLjMwIiwidmVyc2lvbiI6MjUsImNsdXN0ZXJfb3BlcmF0aW9uX3J1bm5pbmciOiJmYWxzZSIs + ImNsdXN0ZXJfb3BlcmF0aW9uX3N0YXR1cyI6IiIsIm9mZmxpbmVfc3RhdHVzIjoiZmFsc2UifQh0 + ZXh03AV7ImNvdW50Ijo4LCJzdGF0dXMiOlt7InZlcnNpb24iOjMzLCJyYW5rIjoxLCJzdGF0dXMi + OiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6Miwic3RhdHVzIjoicnVubmluZyJ9LHsi + dmVyc2lvbiI6MzMsInJhbmsiOjMsInN0YXR1cyI6InJ1bm5pbmcifSx7InZlcnNpb24iOjMzLCJy + YW5rIjo0LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywicmFuayI6NSwic3RhdHVz + IjoicnVubmluZyJ9LHsidmVyc2lvbiI6MzMsInJhbmsiOjYsInN0YXR1cyI6InJ1bm5pbmcifSx7 + InZlcnNpb24iOjMzLCJyYW5rIjo3LCJzdGF0dXMiOiJydW5uaW5nIn0seyJ2ZXJzaW9uIjozMywi + cmFuayI6OCwic3RhdHVzIjoicnVubmluZyJ9XX0QdHJpZ2dlcnNeeyJ0b3RhbF9jb3VudCI6MCwi + cmFuZ2VfY291bnQiOjAsIm5haV9jb3VudCI6MH0AAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:34 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00067' + status: + code: 200 + message: OK +- request: + body: "\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/system/properties + response: + body: + string: !!binary | + BE9LAD5zaG93X3N5c3RlbV9wcm9wZXJ0aWVzX3Jlc3BvbnNlvPUCpAk8Y29uZi5haS5hcGkuY29u + bmVjdGlvbl90aW1lb3V0BDkwHmNvbmYuYWkuYXBpLmtleQAoY29uZi5haS5hcGkucHJvdmlkZXIW + a2luZXRpY2FsbG0eY29uZi5haS5hcGkudXJsSGh0dHA6Ly8xNzIuMzEuMzEuMTM6ODA1MC9zcWwv + c3VnZ2VzdDBjb25mLmFsZXJ0X2Rpc2tfYWJzb2x1dGUANGNvbmYuYWxlcnRfZGlza19wZXJjZW50 + YWdlGDEsIDUsIDEwLCAyMBxjb25mLmFsZXJ0X2V4ZQAsY29uZi5hbGVydF9ob3N0X3N0YXR1cwhU + UlVFOmNvbmYuYWxlcnRfaG9zdF9zdGF0dXNfZmlsdGVyIGZhdGFsX2luaXRfZXJyb3I4Y29uZi5h + bGVydF9tYXhfc3RvcmVkX2FsZXJ0cwYxMDA0Y29uZi5hbGVydF9tZW1vcnlfYWJzb2x1dGUAOGNv + bmYuYWxlcnRfbWVtb3J5X3BlcmNlbnRhZ2UYMSwgNSwgMTAsIDIwNGNvbmYuYWxlcnRfcmFua19j + dWRhX2Vycm9yCFRSVUVEY29uZi5hbGVydF9yYW5rX2ZhbGxiYWNrX2FsbG9jYXRvcghUUlVFLGNv + bmYuYWxlcnRfcmFua19zdGF0dXMIVFJVRTpjb25mLmFsZXJ0X3Jhbmtfc3RhdHVzX2ZpbHRlclhm + YXRhbF9pbml0X2Vycm9yLCBub3RfcmVzcG9uZGluZywgdGVybWluYXRlZB5jb25mLmF1ZGl0X2Jv + ZHkKRkFMU0UeY29uZi5hdWRpdF9kYXRhCkZBTFNFJGNvbmYuYXVkaXRfaGVhZGVycwpGQUxTRT5j + b25mLmF1dG9fY3JlYXRlX2V4dGVybmFsX3VzZXJzCkZBTFNFTGNvbmYuYnVpbGRfbWF0ZXJpYWxp + emVkX3ZpZXdzX29uX3N0YXJ0Em9uX2RlbWFuZDhjb25mLmJ1aWxkX3BrX2luZGV4X29uX3N0YXJ0 + Em9uX2RlbWFuZDhjb25mLmNodW5rX2NvbHVtbl9tYXhfbWVtb3J5EjUxMjAwMDAwMCpjb25mLmNo + dW5rX21heF9tZW1vcnkUODE5MjAwMDAwMB5jb25mLmNodW5rX3NpemUOODAwMDAwMCJjb25mLmNs + dXN0ZXJfbmFtZRxwcm9kdWN0aW9uLW5ld0Bjb25mLmNvbmN1cnJlbnRfa2VybmVsX2V4ZWN1dGlv + bghUUlVFOmNvbmYuZGVmYXVsdF9wcmltYXJ5X2tleV90eXBlDG1lbW9yeSBjb25mLmRlZmF1bHRf + dHRsBDIwLGNvbmYuZGlzYWJsZV9jbGVhcl9hbGwIVFJVRT5jb25mLmVncmVzc19wYXJxdWV0X2Nv + bXByZXNzaW9uDHNuYXBweSRjb25mLmVuYWJsZV9hbGVydHMIVFJVRSJjb25mLmVuYWJsZV9hdWRp + dApGQUxTRTJjb25mLmVuYWJsZV9hdXRob3JpemF0aW9uCFRSVUVGY29uZi5lbmFibGVfZXh0ZXJu + YWxfYXV0aGVudGljYXRpb24KRkFMU0UwY29uZi5lbmFibGVfZ3JhcGhfc2VydmVyCFRSVUUcY29u + Zi5lbmFibGVfaGEKRkFMU0UuY29uZi5lbmFibGVfaHR0cGRfcHJveHkKRkFMU0UcY29uZi5lbmFi + bGVfbWwKRkFMU0U2Y29uZi5lbmFibGVfb3BlbmdsX3JlbmRlcmVyCFRSVUVAY29uZi5lbmFibGVf + b3ZlcmxhcHBlZF9lcXVpX2pvaW4IVFJVRTRjb25mLmVuYWJsZV9wb3N0Z3Jlc19wcm94eQhUUlVF + PmNvbmYuZW5hYmxlX3ByZWRpY2F0ZV9lcXVpX2pvaW4IVFJVRSJjb25mLmVuYWJsZV9wcm9jcwhU + UlVFJGNvbmYuZW5hYmxlX3JldmVhbAhUUlVFMGNvbmYuZW5hYmxlX3N0YXRzX3NlcnZlcghUUlVF + LmNvbmYuZW5hYmxlX3RleHRfc2VhcmNoCFRSVUU8Y29uZi5lbmFibGVfdmVjdG9ydGlsZV9zZXJ2 + aWNlCFRSVUUsY29uZi5lbmFibGVfdnJhbV9jYWNoZQhUUlVFPmNvbmYuZW5hYmxlX3dvcmtlcl9o + dHRwX3NlcnZlcnMIVFJVRTJjb25mLmV2ZW50X3NlcnZlcl9hZGRyZXNzGDE3Mi4zMS4zMy4zMDRj + b25mLmV2ZW50X3NlcnZlcl9pbnRlcm5hbApGQUxTRTpjb25mLmV4dGVybmFsX2ZpbGVzX2RpcmVj + dG9yeSAvbmZzL2RhdGEvcHVibGljFGNvbmYuZ21faXAYMTcyLjMxLjMzLjMwGmNvbmYuZ21fcG9y + dDEINTU1MiBjb25mLmdtX3B1Yl9wb3J0CDU1NTMoY29uZi5ncmFwaC5oZWFkX3BvcnQIODEwMC5j + b25mLmdyYXBoLnNlcnZlcjAuaG9zdApob3N0MC5jb25mLmdyYXBoLnNlcnZlcjAucG9ydAg4MTAx + OGNvbmYuZ3JhcGguc2VydmVyMC5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjEuaG9zdApo + b3N0MS5jb25mLmdyYXBoLnNlcnZlcjEucG9ydAg4MTAyOGNvbmYuZ3JhcGguc2VydmVyMS5yYW1f + bGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjIuaG9zdApob3N0Mi5jb25mLmdyYXBoLnNlcnZlcjIu + cG9ydAg4MTAzOGNvbmYuZ3JhcGguc2VydmVyMi5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZl + cjMuaG9zdApob3N0My5jb25mLmdyYXBoLnNlcnZlcjMucG9ydAg4MTA0OGNvbmYuZ3JhcGguc2Vy + dmVyMy5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjQuaG9zdApob3N0NC5jb25mLmdyYXBo + LnNlcnZlcjQucG9ydAg4MTA1OGNvbmYuZ3JhcGguc2VydmVyNC5yYW1fbGltaXQCMC5jb25mLmdy + YXBoLnNlcnZlcjUuaG9zdApob3N0NS5jb25mLmdyYXBoLnNlcnZlcjUucG9ydAg4MTA2OGNvbmYu + Z3JhcGguc2VydmVyNS5yYW1fbGltaXQCMC5jb25mLmdyYXBoLnNlcnZlcjYuaG9zdApob3N0Ni5j + b25mLmdyYXBoLnNlcnZlcjYucG9ydAg4MTA3OGNvbmYuZ3JhcGguc2VydmVyNi5yYW1fbGltaXQC + MC5jb25mLmdyYXBoLnNlcnZlcjcuaG9zdApob3N0Ny5jb25mLmdyYXBoLnNlcnZlcjcucG9ydAg4 + MTA4OGNvbmYuZ3JhcGguc2VydmVyNy5yYW1fbGltaXQCMBxjb25mLmhhX3F1ZXVlcwAuY29uZi5o + YV9yaW5nX2hlYWRfbm9kZXMAKGNvbmYuaGVhZF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zMBxjb25m + LmhlYWRfcG9ydAg5MTkxImNvbmYuaG1faHR0cF9wb3J0CDkzMDA2Y29uZi5ob3N0MF9hY2NlcHRz + X2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDBfYWRkcmVzcxgxNzIuMzEuMzMuMzAeY29uZi5ob3N0 + MF9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8v + MTcyLjMxLjMzLjMwOjkzMDAsY29uZi5ob3N0MF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMz + LjMwMmNvbmYuaG9zdDBfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMwLGNvbmYuaG9zdDBfcHVi + bGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMChjb25mLmhvc3QwX3JhbV9saW1pdBg2NTY3Njc3 + OTk5OTk2Y29uZi5ob3N0MV9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDFfYWRkcmVz + cxgxNzIuMzEuMzMuMzEeY29uZi5ob3N0MV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0MV9ob3N0X21h + bmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMxOjkzMDAsY29uZi5ob3N0MV9wcml2 + YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMxMmNvbmYuaG9zdDFfcHVibGljX2FkZHJlc3MYMTcy + LjMxLjMzLjMxLGNvbmYuaG9zdDFfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMShjb25m + Lmhvc3QxX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0Ml9hY2NlcHRzX2ZhaWxvdmVy + CkZBTFNFJGNvbmYuaG9zdDJfYWRkcmVzcxgxNzIuMzEuMzMuMzIeY29uZi5ob3N0Ml9ncHVzDjAs + MSwyLDNEY29uZi5ob3N0Ml9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMz + LjMyOjkzMDAsY29uZi5ob3N0Ml9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjMyMmNvbmYu + aG9zdDJfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMyLGNvbmYuaG9zdDJfcHVibGljX3VybHMm + aHR0cDovLzE3Mi4zMS4zMy4zMihjb25mLmhvc3QyX3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29u + Zi5ob3N0M19hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDNfYWRkcmVzcxgxNzIuMzEu + MzMuMzMeY29uZi5ob3N0M19ncHVzDjAsMSwyLDNEY29uZi5ob3N0M19ob3N0X21hbmFnZXJfcHVi + bGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjMzOjkzMDAsY29uZi5ob3N0M19wcml2YXRlX3VybCZo + dHRwOi8vMTcyLjMxLjMzLjMzMmNvbmYuaG9zdDNfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjMz + LGNvbmYuaG9zdDNfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zMyhjb25mLmhvc3QzX3Jh + bV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NF9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNv + bmYuaG9zdDRfYWRkcmVzcxgxNzIuMzEuMzMuMzQeY29uZi5ob3N0NF9ncHVzDjAsMSwyLDNEY29u + Zi5ob3N0NF9ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM0OjkzMDAs + Y29uZi5ob3N0NF9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM0MmNvbmYuaG9zdDRfcHVi + bGljX2FkZHJlc3MYMTcyLjMxLjMzLjM0LGNvbmYuaG9zdDRfcHVibGljX3VybHMmaHR0cDovLzE3 + Mi4zMS4zMy4zNChjb25mLmhvc3Q0X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0NV9h + Y2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDVfYWRkcmVzcxgxNzIuMzEuMzMuMzUeY29u + Zi5ob3N0NV9ncHVzDjAsMSwyLDNEY29uZi5ob3N0NV9ob3N0X21hbmFnZXJfcHVibGljX3VybDBo + dHRwOi8vMTcyLjMxLjMzLjM1OjkzMDAsY29uZi5ob3N0NV9wcml2YXRlX3VybCZodHRwOi8vMTcy + LjMxLjMzLjM1MmNvbmYuaG9zdDVfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM1LGNvbmYuaG9z + dDVfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNShjb25mLmhvc3Q1X3JhbV9saW1pdBg2 + NTY3Njc3OTk5OTk2Y29uZi5ob3N0Nl9hY2NlcHRzX2ZhaWxvdmVyCkZBTFNFJGNvbmYuaG9zdDZf + YWRkcmVzcxgxNzIuMzEuMzMuMzYeY29uZi5ob3N0Nl9ncHVzDjAsMSwyLDNEY29uZi5ob3N0Nl9o + b3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcyLjMxLjMzLjM2OjkzMDAsY29uZi5ob3N0 + Nl9wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM2MmNvbmYuaG9zdDZfcHVibGljX2FkZHJl + c3MYMTcyLjMxLjMzLjM2LGNvbmYuaG9zdDZfcHVibGljX3VybHMmaHR0cDovLzE3Mi4zMS4zMy4z + Nihjb25mLmhvc3Q2X3JhbV9saW1pdBg2NTY3Njc3OTk5OTk2Y29uZi5ob3N0N19hY2NlcHRzX2Zh + aWxvdmVyCkZBTFNFJGNvbmYuaG9zdDdfYWRkcmVzcxgxNzIuMzEuMzMuMzceY29uZi5ob3N0N19n + cHVzDjAsMSwyLDNEY29uZi5ob3N0N19ob3N0X21hbmFnZXJfcHVibGljX3VybDBodHRwOi8vMTcy + LjMxLjMzLjM3OjkzMDAsY29uZi5ob3N0N19wcml2YXRlX3VybCZodHRwOi8vMTcyLjMxLjMzLjM3 + MmNvbmYuaG9zdDdfcHVibGljX2FkZHJlc3MYMTcyLjMxLjMzLjM3LGNvbmYuaG9zdDdfcHVibGlj + X3VybHMmaHR0cDovLzE3Mi4zMS4zMy4zNyhjb25mLmhvc3Q3X3JhbV9saW1pdBg2NTY3Njc3OTk5 + OTkqY29uZi5odHRwZF9wcm94eV9wb3J0CDgwODI0Y29uZi5odHRwZF9wcm94eV91c2VfaHR0cHMK + RkFMU0U4Y29uZi5pbml0X3dpdGhfbm93X2F0X3dvcmtlcgpGQUxTRSpjb25mLmthZmthLmJhdGNo + X3NpemUIMTAwMC5jb25mLmthZmthLnBvbGxfdGltZW91dAIwKGNvbmYua2Fma2Eud2FpdF90aW1l + BDMwLmNvbmYua2VybmVsX29tcF90aHJlYWRzAjQ0Y29uZi5sb2FkX3ZlY3RvcnNfb25fc3RhcnQS + b25fZGVtYW5kHmNvbmYubG9ja19hdWRpdApGQUxTRTZjb25mLm1heF9hdXRvX3ZpZXdfdXBkYXRv + cnMCMzZjb25mLm1heF9jb25jdXJyZW50X2tlcm5lbHMCMDJjb25mLm1heF9nZXRfcmVjb3Jkc19z + aXplCjIwMDAwKmNvbmYubWF4X2hlYXRtYXBfc2l6ZQgzMDcyKmNvbmYubWF4X2h0dHBfdGhyZWFk + cwY1MTI6Y29uZi5tZXRhZGF0YV9zdG9yZV9zeW5jX21vZGUMbm9ybWFsKmNvbmYubWluX2h0dHBf + dGhyZWFkcwI4MGNvbmYubWluX3Bhc3N3b3JkX2xlbmd0aAIwIGNvbmYubWxfYXBpX3BvcnQIOTE4 + N1xjb25mLm5wMS5idWlsZF9tYXRlcmlhbGl6ZWRfdmlld3Nfb25fbWlncmF0aW9uDGFsd2F5c0hj + b25mLm5wMS5idWlsZF9wa19pbmRleF9vbl9taWdyYXRpb24MYWx3YXlzRGNvbmYubnAxLmNyaXRp + Y2FsX3Jlc3RhcnRfYXR0ZW1wdHMCMTpjb25mLm5wMS5lbmFibGVfaGVhZF9mYWlsb3ZlcgpGQUxT + RT5jb25mLm5wMS5lbmFibGVfd29ya2VyX2ZhaWxvdmVyCkZBTFNFSmNvbmYubnAxLmZhaWxvdmVy + X2Rpc3RyaWJ1dGlvbl9wb2xpY3kIZmlsbERjb25mLm5wMS5sb2FkX3ZlY3RvcnNfb25fbWlncmF0 + aW9uDGFsd2F5c0xjb25mLm5wMS5ub25fY3JpdGljYWxfcmVzdGFydF9hdHRlbXB0cwIzPGNvbmYu + bnAxLnJhbmtfcmVzdGFydF9hdHRlbXB0cwIxMmNvbmYubnAxLnJlc3RhcnRfaW50ZXJ2YWwENjA2 + Y29uZi5ucDEuc3RvcmFnZV9hcGlfc2NyaXB0AChjb25mLm51bWJlcl9vZl9ob3N0cwI4KGNvbmYu + bnVtYmVyX29mX3JhbmtzAjk8Y29uZi5vcGVuZ2xfYW50aWFsaWFzaW5nX2xldmVsAjAsY29uZi5w + ZXJzaXN0X2RpcmVjdG9yeTAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8sY29uZi5wZXJzaXN0X3N5 + bmNfdGltZQI1NmNvbmYucG9pbnRfcmVuZGVyX3RocmVzaG9sZAwxMDAwMDBWY29uZi5wb3N0Z3Jl + c19wcm94eS5pZGxlX2Nvbm5lY3Rpb25fdGltZW91dAYzMDBUY29uZi5wb3N0Z3Jlc19wcm94eS5t + YXhfcXVldWVkX2Nvbm5lY3Rpb25zAjE+Y29uZi5wb3N0Z3Jlc19wcm94eS5tYXhfdGhyZWFkcwQ2 + ND5jb25mLnBvc3RncmVzX3Byb3h5Lm1pbl90aHJlYWRzAjIwY29uZi5wb3N0Z3Jlc19wcm94eS5w + b3J0CDU0MzIuY29uZi5wb3N0Z3Jlc19wcm94eS5zc2wIVFJVRRxjb25mLnJhbmswX2dwdQIwKmNv + bmYucmFuazBfaXBfYWRkcmVzcxgxNzIuMzEuMzMuMzAqY29uZi5yYW5rMV9pcF9hZGRyZXNzGDE3 + Mi4zMS4zMy4zMCpjb25mLnJhbmsyX2lwX2FkZHJlc3MYMTcyLjMxLjMzLjMxKmNvbmYucmFuazNf + aXBfYWRkcmVzcxgxNzIuMzEuMzMuMzIqY29uZi5yYW5rNF9pcF9hZGRyZXNzGDE3Mi4zMS4zMy4z + Mypjb25mLnJhbms1X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM0KmNvbmYucmFuazZfaXBfYWRkcmVz + cxgxNzIuMzEuMzMuMzUqY29uZi5yYW5rN19pcF9hZGRyZXNzGDE3Mi4zMS4zMy4zNipjb25mLnJh + bms4X2lwX2FkZHJlc3MYMTcyLjMxLjMzLjM3KGNvbmYucmVxdWVzdF90aW1lb3V0CDI0MDA2Y29u + Zi5yZXF1aXJlX2F1dGhlbnRpY2F0aW9uCFRSVUVeY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0 + Lm1heF9jcHVfY29uY3VycmVuY3kELTFaY29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0Lm1heF90 + aWVyX3ByaW9yaXR5BDEwSmNvbmYucmVzb3VyY2VfZ3JvdXAuZGVmYXVsdC5yYW1fbGltaXQELTFa + Y29uZi5yZXNvdXJjZV9ncm91cC5kZWZhdWx0LnNjaGVkdWxlX3ByaW9yaXR5BDUwTGNvbmYucmVz + b3VyY2VfZ3JvdXAuZGVmYXVsdC52cmFtX2xpbWl0BC0xHGNvbmYucmluZ19uYW1lDmRlZmF1bHRW + Y29uZi5zZWN1cml0eS5leHRlcm5hbC5yYW5nZXIuY2FjaGVfbWludXRlcwQ2MFRjb25mLnNlY3Vy + aXR5LmV4dGVybmFsLnJhbmdlci5zZXJ2aWNlX25hbWUQa2luZXRpY2FCY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXIudXJsAGBjb25mLnNlY3VyaXR5LmV4dGVybmFsLnJhbmdlcl9hdXRob3Jp + emVyLmFkZHJlc3MyaXBjOi8vL3RtcC9ncHVkYi1yYW5nZXItMHRjb25mLnNlY3VyaXR5LmV4dGVy + bmFsLnJhbmdlcl9hdXRob3JpemVyLnJlbW90ZV9kZWJ1Z19wb3J0AjBgY29uZi5zZWN1cml0eS5l + eHRlcm5hbC5yYW5nZXJfYXV0aG9yaXplci50aW1lb3V0BjEyMCpjb25mLnNldF9tb25pdG9yX3Bv + cnQIOTAwMjZjb25mLnNldF9tb25pdG9yX3Byb3h5X3BvcnQIOTAwMzZjb25mLnNldF9tb25pdG9y + X3F1ZXVlX3NpemUIMTAwMChjb25mLnNoYWRvd19hZ2dfc2l6ZRI1MDAwMDAwMDAwY29uZi5zaGFk + b3dfY3ViZV9lbmFibGVkCFRSVUUuY29uZi5zaGFkb3dfZmlsdGVyX3NpemUSNTAwMDAwMDAwJmNv + bmYuc21fb21wX3RocmVhZHMCMiRjb25mLnNtc19kaXJlY3RvcnkwL21udC9kYXRhL2dwdWRiL3Bl + cnNpc3QvLmNvbmYuc21zX21heF9vcGVuX2ZpbGVzBjEyOEBjb25mLnNxbC5jb3N0X2Jhc2VkX29w + dGltaXphdGlvbgpGQUxTRTRjb25mLnNxbC5kaXN0cmlidXRlZF9qb2lucwhUUlVFPmNvbmYuc3Fs + LmRpc3RyaWJ1dGVkX29wZXJhdGlvbnMIVFJVRS5jb25mLnNxbC5lbmFibGVfcGxhbm5lcghUUlVF + NmNvbmYuc3FsLmZvcmNlX2JpbmFyeV9qb2lucwpGQUxTRTpjb25mLnNxbC5mb3JjZV9iaW5hcnlf + c2V0X29wcwpGQUxTRTZjb25mLnNxbC5tYXhfcGFyYWxsZWxfc3RlcHMCNEBjb25mLnNxbC5tYXhf + dmlld19uZXN0aW5nX2xldmVscwQxNjJjb25mLnNxbC5wYWdpbmdfdGFibGVfdHRsBDIwNmNvbmYu + c3FsLnBhcmFsbGVsX2V4ZWN1dGlvbghUUlVFMGNvbmYuc3FsLnBsYW5fY2FjaGVfc2l6ZQg0MDAw + MGNvbmYuc3FsLnBsYW5uZXIuYWRkcmVzcz5pcGM6Ly8vdG1wL2dwdWRiLXF1ZXJ5LWVuZ2luZS0w + NmNvbmYuc3FsLnBsYW5uZXIubWF4X21lbW9yeQg0MDk2NGNvbmYuc3FsLnBsYW5uZXIubWF4X3N0 + YWNrAjZEY29uZi5zcWwucGxhbm5lci5yZW1vdGVfZGVidWdfcG9ydAIwMGNvbmYuc3FsLnBsYW5u + ZXIudGltZW91dAYxMjA0Y29uZi5zcWwucmVzdWx0X2NhY2hlX3NpemUINDAwMDRjb25mLnNxbC5y + ZXN1bHRzLmNhY2hlX3R0bAQ2MDBjb25mLnNxbC5yZXN1bHRzLmNhY2hpbmcIVFJVRUBjb25mLnNx + bC5ydWxlX2Jhc2VkX29wdGltaXphdGlvbghUUlVFPGNvbmYuc3VidGFza19jb25jdXJyZW5jeV9s + aW1pdAI0PmNvbmYuc3ltYm9sb2d5X3JlbmRlcl90aHJlc2hvbGQKMTAwMDBQY29uZi5zeXN0ZW1f + bWV0YWRhdGEuc3RhdHNfYWdncl9yb3djb3VudAoxMDAwMEhjb25mLnN5c3RlbV9tZXRhZGF0YS5z + dGF0c19hZ2dyX3RpbWUCMVJjb25mLnN5c3RlbV9tZXRhZGF0YS5zdGF0c19yZXRlbnRpb25fZGF5 + cwQyMSZjb25mLnRhc2tjYWxjX2dwdS4xElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4yElsw + LDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS4zElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS40 + ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS41ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dw + dS42ElswLDEsMiwzXSZjb25mLnRhc2tjYWxjX2dwdS43ElswLDEsMiwzXSZjb25mLnRhc2tjYWxj + X2dwdS44ElswLDEsMiwzXSBjb25mLnRjc19wZXJfdG9tBDQwJmNvbmYudGVtcF9kaXJlY3RvcnkI + L3RtcDJjb25mLnRleHRfaW5kZXhfZGlyZWN0b3J5MC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0LzJj + b25mLnRleHRfaW5kaWNlc19wZXJfdG9tAjJMY29uZi50aWVyLmRpc2swLmRlZmF1bHQuaGlnaF93 + YXRlcm1hcmsEOTA6Y29uZi50aWVyLmRpc2swLmRlZmF1bHQubGltaXQYNjAwMDAwMDAwMDAwSmNv + bmYudGllci5kaXNrMC5kZWZhdWx0Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLmRpc2swLmRl + ZmF1bHQucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlYGNvbmYudGllci5k + aXNrMC5kZWZhdWx0LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlz + azAucmFuazAuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbmswLmxpbWl0GDYw + MDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazAubG93X3dhdGVybWFyawQ4MDRjb25mLnRp + ZXIuZGlzazAucmFuazAucGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNv + bmYudGllci5kaXNrMC5yYW5rMC5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50 + aWVyLmRpc2swLnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rMS5s + aW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJhbmsxLmxvd193YXRlcm1hcmsEODA0 + Y29uZi50aWVyLmRpc2swLnJhbmsxLnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tj + YWNoZVxjb25mLnRpZXIuZGlzazAucmFuazEuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNF + SGNvbmYudGllci5kaXNrMC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAu + cmFuazIubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rMi5sb3dfd2F0ZXJt + YXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rMi5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0 + Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbmsyLnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0 + cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazMuaGlnaF93YXRlcm1hcmsEOTA2Y29uZi50aWVy + LmRpc2swLnJhbmszLmxpbWl0GDYwMDAwMDAwMDAwMEZjb25mLnRpZXIuZGlzazAucmFuazMubG93 + X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazMucGF0aEQvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5yYW5rMy5zdG9yZV9wZXJzaXN0ZW50 + X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNv + bmYudGllci5kaXNrMC5yYW5rNC5saW1pdBg2MDAwMDAwMDAwMDBGY29uZi50aWVyLmRpc2swLnJh + bms0Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2swLnJhbms0LnBhdGhEL21udC9kYXRh + L2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIuZGlzazAucmFuazQuc3RvcmVfcGVy + c2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNrMC5yYW5rNS5oaWdoX3dhdGVybWFy + awQ5MDZjb25mLnRpZXIuZGlzazAucmFuazUubGltaXQYNjAwMDAwMDAwMDAwRmNvbmYudGllci5k + aXNrMC5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGllci5kaXNrMC5yYW5rNS5wYXRoRC9t + bnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29uZi50aWVyLmRpc2swLnJhbms1LnN0 + b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRUhjb25mLnRpZXIuZGlzazAucmFuazYuaGlnaF93 + YXRlcm1hcmsEOTA2Y29uZi50aWVyLmRpc2swLnJhbms2LmxpbWl0GDYwMDAwMDAwMDAwMEZjb25m + LnRpZXIuZGlzazAucmFuazYubG93X3dhdGVybWFyawQ4MDRjb25mLnRpZXIuZGlzazAucmFuazYu + cGF0aEQvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC8vZGlza2NhY2hlXGNvbmYudGllci5kaXNrMC5y + YW5rNi5zdG9yZV9wZXJzaXN0ZW50X29iamVjdHMKRkFMU0VIY29uZi50aWVyLmRpc2swLnJhbms3 + LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5kaXNrMC5yYW5rNy5saW1pdBg2MDAwMDAwMDAw + MDBGY29uZi50aWVyLmRpc2swLnJhbms3Lmxvd193YXRlcm1hcmsEODA0Y29uZi50aWVyLmRpc2sw + LnJhbms3LnBhdGhEL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvL2Rpc2tjYWNoZVxjb25mLnRpZXIu + ZGlzazAucmFuazcuc3RvcmVfcGVyc2lzdGVudF9vYmplY3RzCkZBTFNFSGNvbmYudGllci5kaXNr + MC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDZjb25mLnRpZXIuZGlzazAucmFuazgubGltaXQYNjAw + MDAwMDAwMDAwRmNvbmYudGllci5kaXNrMC5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwNGNvbmYudGll + ci5kaXNrMC5yYW5rOC5wYXRoRC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Ly9kaXNrY2FjaGVcY29u + Zi50aWVyLmRpc2swLnJhbms4LnN0b3JlX3BlcnNpc3RlbnRfb2JqZWN0cwpGQUxTRVBjb25mLnRp + ZXIuZ2xvYmFsLmNvbmN1cnJlbnRfd2FpdF90aW1lb3V0BjYwMGpjb25mLnRpZXIuZ2xvYmFsLmRl + ZmVyX2NhY2hlX29iamVjdF9ldmljdGlvbnNfdG9fZGlzawhUUlVFUGNvbmYudGllci5wZXJzaXN0 + LmRlZmF1bHQuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnBlcnNpc3QuZGVmYXVsdC5saW1p + dBo2NTAwMDAwMDAwMDAwTmNvbmYudGllci5wZXJzaXN0LmRlZmF1bHQubG93X3dhdGVybWFyawQ4 + MDxjb25mLnRpZXIucGVyc2lzdC5kZWZhdWx0LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3Qv + OmNvbmYudGllci5wZXJzaXN0LmdyYXBoMC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpj + b25mLnRpZXIucGVyc2lzdC5ncmFwaDEucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29u + Zi50aWVyLnBlcnNpc3QuZ3JhcGgyLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYu + dGllci5wZXJzaXN0LmdyYXBoMy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRp + ZXIucGVyc2lzdC5ncmFwaDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC86Y29uZi50aWVy + LnBlcnNpc3QuZ3JhcGg1LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvOmNvbmYudGllci5w + ZXJzaXN0LmdyYXBoNi5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0Lzpjb25mLnRpZXIucGVy + c2lzdC5ncmFwaDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNp + c3QucmFuazAuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazAubGltaXQa + NjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwOGNv + bmYudGllci5wZXJzaXN0LnJhbmswLnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYu + dGllci5wZXJzaXN0LnJhbmsxLmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJh + bmsxLmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazEubG93X3dhdGVy + bWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rMS5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJz + aXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rMi5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIu + cGVyc2lzdC5yYW5rMi5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbmsy + Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazIucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBlcnNpc3QucmFuazMuaGlnaF93YXRlcm1hcmsEOTA6 + Y29uZi50aWVyLnBlcnNpc3QucmFuazMubGltaXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVy + c2lzdC5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwOGNvbmYudGllci5wZXJzaXN0LnJhbmszLnBhdGgw + L21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNvbmYudGllci5wZXJzaXN0LnJhbms0LmhpZ2hfd2F0 + ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0LnJhbms0LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29u + Zi50aWVyLnBlcnNpc3QucmFuazQubG93X3dhdGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5y + YW5rNC5wYXRoMC9tbnQvZGF0YS9ncHVkYi9wZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5r + NS5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRpZXIucGVyc2lzdC5yYW5rNS5saW1pdBo2NTAwMDAw + MDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJhbms1Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVy + LnBlcnNpc3QucmFuazUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9MY29uZi50aWVyLnBl + cnNpc3QucmFuazYuaGlnaF93YXRlcm1hcmsEOTA6Y29uZi50aWVyLnBlcnNpc3QucmFuazYubGlt + aXQaNjUwMDAwMDAwMDAwMEpjb25mLnRpZXIucGVyc2lzdC5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgw + OGNvbmYudGllci5wZXJzaXN0LnJhbms2LnBhdGgwL21udC9kYXRhL2dwdWRiL3BlcnNpc3QvTGNv + bmYudGllci5wZXJzaXN0LnJhbms3LmhpZ2hfd2F0ZXJtYXJrBDkwOmNvbmYudGllci5wZXJzaXN0 + LnJhbms3LmxpbWl0GjY1MDAwMDAwMDAwMDBKY29uZi50aWVyLnBlcnNpc3QucmFuazcubG93X3dh + dGVybWFyawQ4MDhjb25mLnRpZXIucGVyc2lzdC5yYW5rNy5wYXRoMC9tbnQvZGF0YS9ncHVkYi9w + ZXJzaXN0L0xjb25mLnRpZXIucGVyc2lzdC5yYW5rOC5oaWdoX3dhdGVybWFyawQ5MDpjb25mLnRp + ZXIucGVyc2lzdC5yYW5rOC5saW1pdBo2NTAwMDAwMDAwMDAwSmNvbmYudGllci5wZXJzaXN0LnJh + bms4Lmxvd193YXRlcm1hcmsEODA4Y29uZi50aWVyLnBlcnNpc3QucmFuazgucGF0aDAvbW50L2Rh + dGEvZ3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDEucGF0aDAvbW50L2RhdGEv + Z3B1ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDIucGF0aDAvbW50L2RhdGEvZ3B1 + ZGIvcGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDMucGF0aDAvbW50L2RhdGEvZ3B1ZGIv + cGVyc2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDQucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVy + c2lzdC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDUucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lz + dC84Y29uZi50aWVyLnBlcnNpc3QudGV4dDYucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84 + Y29uZi50aWVyLnBlcnNpc3QudGV4dDcucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC84Y29u + Zi50aWVyLnBlcnNpc3QudGV4dDgucGF0aDAvbW50L2RhdGEvZ3B1ZGIvcGVyc2lzdC9IY29uZi50 + aWVyLnJhbS5kZWZhdWx0LmhpZ2hfd2F0ZXJtYXJrBDkwNmNvbmYudGllci5yYW0uZGVmYXVsdC5s + aW1pdAQtMUZjb25mLnRpZXIucmFtLmRlZmF1bHQubG93X3dhdGVybWFyawQ4MERjb25mLnRpZXIu + cmFtLnJhbmswLmhpZ2hfd2F0ZXJtYXJrBDkwMmNvbmYudGllci5yYW0ucmFuazAubGltaXQWNzcy + NjY4MDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazEuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazIuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazMuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rMy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rMy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazQuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNC5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazUuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNS5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNS5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazYuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNi5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNi5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazcuaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rNy5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rNy5sb3dfd2F0ZXJtYXJrBDgwRGNvbmYudGllci5y + YW0ucmFuazguaGlnaF93YXRlcm1hcmsEOTAyY29uZi50aWVyLnJhbS5yYW5rOC5saW1pdBg2MDAw + MDAwMDAwMDBCY29uZi50aWVyLnJhbS5yYW5rOC5sb3dfd2F0ZXJtYXJrBDgwXGNvbmYudGllci52 + cmFtLmRlZmF1bHQuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBKY29uZi50aWVyLnZyYW0uZGVm + YXVsdC5hbGxfZ3B1cy5saW1pdAQtMVpjb25mLnRpZXIudnJhbS5kZWZhdWx0LmFsbF9ncHVzLmxv + d193YXRlcm1hcmsEODBUY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUwLmhpZ2hfd2F0ZXJtYXJr + BDkwQmNvbmYudGllci52cmFtLmRlZmF1bHQuZ3B1MC5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5k + ZWZhdWx0LmdwdTAubG93X3dhdGVybWFyawQ4MFRjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTEu + aGlnaF93YXRlcm1hcmsEOTBCY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUxLmxpbWl0BC0xUmNv + bmYudGllci52cmFtLmRlZmF1bHQuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwVGNvbmYudGllci52cmFt + LmRlZmF1bHQuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MEJjb25mLnRpZXIudnJhbS5kZWZhdWx0Lmdw + dTIubGltaXQELTFSY29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUyLmxvd193YXRlcm1hcmsEODBU + Y29uZi50aWVyLnZyYW0uZGVmYXVsdC5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwQmNvbmYudGllci52 + cmFtLmRlZmF1bHQuZ3B1My5saW1pdAQtMVJjb25mLnRpZXIudnJhbS5kZWZhdWx0LmdwdTMubG93 + X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMC5HUFUwLmhpZ2hfd2F0ZXJtYXJrBDkw + PmNvbmYudGllci52cmFtLnJhbmswLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAu + R1BVMC5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmhpZ2hf + d2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYu + dGllci52cmFtLnJhbmswLmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazAuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUwLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rMC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsw + LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbmswLmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazAuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMC5ncHUyLmxvd193YXRl + cm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazAuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25m + LnRpZXIudnJhbS5yYW5rMC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmswLmdwdTMu + bG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5HUFUwLmhpZ2hfd2F0ZXJtYXJr + BDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFu + azEuR1BVMC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLkdQVTEuaGlnaF93 + YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuR1BVMS5saW1pdAQtMU5jb25mLnRpZXIu + dnJhbS5yYW5rMS5HUFUxLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuR1BV + Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5HUFUyLmxpbWl0BC0xTmNv + bmYudGllci52cmFtLnJhbmsxLkdQVTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5y + YW5rMS5HUFUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLkdQVTMubGlt + aXQELTFOY29uZi50aWVyLnZyYW0ucmFuazEuR1BVMy5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGll + ci52cmFtLnJhbmsxLmFsbF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJh + bmsxLmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGllci52cmFtLnJhbmsxLmFsbF9ncHVzLmxvd193 + YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5j + b25mLnRpZXIudnJhbS5yYW5rMS5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsxLmdw + dTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMS5ncHUxLmhpZ2hfd2F0ZXJt + YXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsxLmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0u + cmFuazEuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsxLmdwdTIuaGln + aF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazEuZ3B1Mi5saW1pdAQtMU5jb25mLnRp + ZXIudnJhbS5yYW5rMS5ncHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazEu + Z3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMS5ncHUzLmxpbWl0BC0x + TmNvbmYudGllci52cmFtLnJhbmsxLmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJh + bS5yYW5rMi5hbGxfZ3B1cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rMi5h + bGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJhbS5yYW5rMi5hbGxfZ3B1cy5sb3dfd2F0ZXJt + YXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50 + aWVyLnZyYW0ucmFuazIuZ3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUwLmxv + d193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazIuZ3B1MS5oaWdoX3dhdGVybWFyawQ5 + MD5jb25mLnRpZXIudnJhbS5yYW5rMi5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbmsy + LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMi5ncHUyLmhpZ2hfd2F0 + ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmsyLmdwdTIubGltaXQELTFOY29uZi50aWVyLnZy + YW0ucmFuazIuZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmsyLmdwdTMu + aGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazIuZ3B1My5saW1pdAQtMU5jb25m + LnRpZXIudnJhbS5yYW5rMi5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFu + azMuYWxsX2dwdXMuaGlnaF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dw + dXMubGltaXQELTFWY29uZi50aWVyLnZyYW0ucmFuazMuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4 + MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52 + cmFtLnJhbmszLmdwdTAubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1MC5sb3dfd2F0 + ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbmszLmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29u + Zi50aWVyLnZyYW0ucmFuazMuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUx + Lmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazMuZ3B1Mi5oaWdoX3dhdGVybWFy + awQ5MD5jb25mLnRpZXIudnJhbS5yYW5rMy5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJh + bmszLmdwdTIubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rMy5ncHUzLmhpZ2hf + d2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbmszLmdwdTMubGltaXQELTFOY29uZi50aWVy + LnZyYW0ucmFuazMuZ3B1My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms0LmFs + bF9ncHVzLmhpZ2hfd2F0ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxp + bWl0BC0xVmNvbmYudGllci52cmFtLnJhbms0LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29u + Zi50aWVyLnZyYW0ucmFuazQuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5y + YW5rNC5ncHUwLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms0LmdwdTAubG93X3dhdGVybWFy + awQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNC5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGll + ci52cmFtLnJhbms0LmdwdTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1MS5sb3df + d2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms0LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+ + Y29uZi50aWVyLnZyYW0ucmFuazQuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNC5n + cHUyLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFuazQuZ3B1My5oaWdoX3dhdGVy + bWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNC5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFt + LnJhbms0LmdwdTMubG93X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1 + cy5oaWdoX3dhdGVybWFyawQ5MEZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5saW1pdAQt + MVZjb25mLnRpZXIudnJhbS5yYW5rNS5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGll + ci52cmFtLnJhbms1LmdwdTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazUu + Z3B1MC5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNS5ncHUwLmxvd193YXRlcm1hcmsEODBQ + Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJh + bS5yYW5rNS5ncHUxLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms1LmdwdTEubG93X3dhdGVy + bWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNS5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYu + dGllci52cmFtLnJhbms1LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazUuZ3B1Mi5s + b3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms1LmdwdTMuaGlnaF93YXRlcm1hcmsE + OTA+Y29uZi50aWVyLnZyYW0ucmFuazUuZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5r + NS5ncHUzLmxvd193YXRlcm1hcmsEODBYY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMuaGln + aF93YXRlcm1hcmsEOTBGY29uZi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubGltaXQELTFWY29u + Zi50aWVyLnZyYW0ucmFuazYuYWxsX2dwdXMubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIudnJh + bS5yYW5rNi5ncHUwLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms2LmdwdTAu + bGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1MC5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYu + dGllci52cmFtLnJhbms2LmdwdTEuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFu + azYuZ3B1MS5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNi5ncHUxLmxvd193YXRlcm1hcmsE + ODBQY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1Mi5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIu + dnJhbS5yYW5rNi5ncHUyLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms2LmdwdTIubG93X3dh + dGVybWFyawQ4MFBjb25mLnRpZXIudnJhbS5yYW5rNi5ncHUzLmhpZ2hfd2F0ZXJtYXJrBDkwPmNv + bmYudGllci52cmFtLnJhbms2LmdwdTMubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazYuZ3B1 + My5sb3dfd2F0ZXJtYXJrBDgwWGNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmhpZ2hfd2F0 + ZXJtYXJrBDkwRmNvbmYudGllci52cmFtLnJhbms3LmFsbF9ncHVzLmxpbWl0BC0xVmNvbmYudGll + ci52cmFtLnJhbms3LmFsbF9ncHVzLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0ucmFu + azcuZ3B1MC5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUwLmxpbWl0 + BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTAubG93X3dhdGVybWFyawQ4MFBjb25mLnRpZXIu + dnJhbS5yYW5rNy5ncHUxLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms3Lmdw + dTEubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1MS5sb3dfd2F0ZXJtYXJrBDgwUGNv + bmYudGllci52cmFtLnJhbms3LmdwdTIuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0u + cmFuazcuZ3B1Mi5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rNy5ncHUyLmxvd193YXRlcm1h + cmsEODBQY29uZi50aWVyLnZyYW0ucmFuazcuZ3B1My5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRp + ZXIudnJhbS5yYW5rNy5ncHUzLmxpbWl0BC0xTmNvbmYudGllci52cmFtLnJhbms3LmdwdTMubG93 + X3dhdGVybWFyawQ4MFhjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5oaWdoX3dhdGVybWFy + awQ5MEZjb25mLnRpZXIudnJhbS5yYW5rOC5hbGxfZ3B1cy5saW1pdAQtMVZjb25mLnRpZXIudnJh + bS5yYW5rOC5hbGxfZ3B1cy5sb3dfd2F0ZXJtYXJrBDgwUGNvbmYudGllci52cmFtLnJhbms4Lmdw + dTAuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZyYW0ucmFuazguZ3B1MC5saW1pdAQtMU5j + b25mLnRpZXIudnJhbS5yYW5rOC5ncHUwLmxvd193YXRlcm1hcmsEODBQY29uZi50aWVyLnZyYW0u + cmFuazguZ3B1MS5oaWdoX3dhdGVybWFyawQ5MD5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUxLmxp + bWl0BC0xTmNvbmYudGllci52cmFtLnJhbms4LmdwdTEubG93X3dhdGVybWFyawQ4MFBjb25mLnRp + ZXIudnJhbS5yYW5rOC5ncHUyLmhpZ2hfd2F0ZXJtYXJrBDkwPmNvbmYudGllci52cmFtLnJhbms4 + LmdwdTIubGltaXQELTFOY29uZi50aWVyLnZyYW0ucmFuazguZ3B1Mi5sb3dfd2F0ZXJtYXJrBDgw + UGNvbmYudGllci52cmFtLnJhbms4LmdwdTMuaGlnaF93YXRlcm1hcmsEOTA+Y29uZi50aWVyLnZy + YW0ucmFuazguZ3B1My5saW1pdAQtMU5jb25mLnRpZXIudnJhbS5yYW5rOC5ncHUzLmxvd193YXRl + cm1hcmsEODA0Y29uZi50aWVyX3N0cmF0ZWd5LmRlZmF1bHRCVlJBTSAyLCBSQU0gNSwgRElTSzAg + NSwgUEVSU0lTVCA1YGNvbmYudGllcl9zdHJhdGVneS5wcmVkaWNhdGVfZXZhbHVhdGlvbl9pbnRl + cnZhbAQ2MCRjb25mLnRvbXNfcGVyX3JhbmsCMSBjb25mLnRwc19wZXJfdG9tBDQwImNvbmYudHJp + Z2dlcl9wb3J0CDkwMDE+Y29uZi51bmlmaWVkX3NlY3VyaXR5X25hbWVzcGFjZQpGQUxTRTpjb25m + LnVzZV9leHRlcm5hbF90ZXh0X3NlcnZlcghUUlVFHGNvbmYudXNlX2h0dHBzCkZBTFNFLGNvbmYu + dmlkZW9fZGVmYXVsdF90dGwELTEoY29uZi52aWRlb19tYXhfY291bnQELTEyY29uZi52aWRlb190 + ZW1wX2RpcmVjdG9yeSwvdG1wL2dwdWRiLXRlbXAtdmlkZW9zImNvbmYud2FsLmNoZWNrc3VtCFRS + VUUwY29uZi53YWwuZmx1c2hfZnJlcXVlbmN5BDYwMmNvbmYud2FsLm1heF9zZWdtZW50X3NpemUS + NTAwMDAwMDAwLGNvbmYud2FsLnNlZ21lbnRfY291bnQELTEoY29uZi53YWwuc3luY19wb2xpY3kK + Zmx1c2g2Y29uZi53b3JrZXJfaHR0cF9zZXJ2ZXJfaXBz6AExNzIuMzEuMzMuMzA7MTcyLjMxLjMz + LjMwOzE3Mi4zMS4zMy4zMTsxNzIuMzEuMzMuMzI7MTcyLjMxLjMzLjMzOzE3Mi4zMS4zMy4zNDsx + NzIuMzEuMzMuMzU7MTcyLjMxLjMzLjM2OzE3Mi4zMS4zMy4zNzpjb25mLndvcmtlcl9odHRwX3Nl + cnZlcl9wb3J0c1g5MTkxOzkxOTI7OTE5Mzs5MTk0OzkxOTU7OTE5Njs5MTk3OzkxOTg7OTE5OThj + b25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzwANodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTE7aHR0 + cDovLzE3Mi4zMS4zMy4zMDo5MTkyO2h0dHA6Ly8xNzIuMzEuMzMuMzE6OTE5MztodHRwOi8vMTcy + LjMxLjMzLjMyOjkxOTQ7aHR0cDovLzE3Mi4zMS4zMy4zMzo5MTk1O2h0dHA6Ly8xNzIuMzEuMzMu + MzQ6OTE5NjtodHRwOi8vMTcyLjMxLjMzLjM1OjkxOTc7aHR0cDovLzE3Mi4zMS4zMy4zNjo5MTk4 + O2h0dHA6Ly8xNzIuMzEuMzMuMzc6OTE5OUhjb25mLndvcmtlcl9odHRwX3NlcnZlcl91cmxzX3By + aXZhdGXAA2h0dHA6Ly8xNzIuMzEuMzMuMzA6OTE5MTtodHRwOi8vMTcyLjMxLjMzLjMwOjkxOTI7 + aHR0cDovLzE3Mi4zMS4zMy4zMTo5MTkzO2h0dHA6Ly8xNzIuMzEuMzMuMzI6OTE5NDtodHRwOi8v + MTcyLjMxLjMzLjMzOjkxOTU7aHR0cDovLzE3Mi4zMS4zMy4zNDo5MTk2O2h0dHA6Ly8xNzIuMzEu + MzMuMzU6OTE5NztodHRwOi8vMTcyLjMxLjMzLjM2OjkxOTg7aHR0cDovLzE3Mi4zMS4zMy4zNzo5 + MTk5KHN5c3RlbS5mb250X2ZhbWlsaWVzpgFEZWphVnUgTWF0aCBUZVggR3lyZSxEZWphVnUgU2Fu + cyBNb25vLERlamFWdSBTYW5zLERlamFWdSBTZXJpZixTYW5zLFNlcmlmLE1vbm9zcGFjZTB2ZXJz + aW9uLmdwdWRiX2J1aWxkX2RhdGUoRmViIDE0IDIwMjQgMjM6NDk6MDFAdmVyc2lvbi5ncHVkYl9j + b21wdXRlX2NhcGFiaWxpdHkWNjA7NzA7ODA7ODY4dmVyc2lvbi5ncHVkYl9jb21wdXRlX2VuZ2lu + ZQhDVURBPnZlcnNpb24uZ3B1ZGJfY29yZV9saWJzX3ZlcnNpb24UMjAyNDAyMTMwMDR2ZXJzaW9u + LmdwdWRiX2NvcmVfdmVyc2lvbiw3LjIuMC4xLjIwMjQwMjE0MjEwOTA2NHZlcnNpb24uZ3B1ZGJf + ZmlsZV92ZXJzaW9uFDIwMjEwMzExMjAqdmVyc2lvbi5ncHVkYl92ZXJzaW9uUDkyMjYwYTMyOWNh + NDVjYjBlMzc3NzZjZjkxNDQ5NzE3OWY2MjExNDM0dmVyc2lvbi5ncHVkYl92ZXJzaW9uX2RhdGUy + MjAyNC0wMi0xNCAyMTowOTowNiAtMDUwMCx2ZXJzaW9uLnB5dGhvbl92ZXJzaW9uDjMuMTAuMTMA + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:34 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00063' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/has/table + response: + body: + string: "\x04OK\0$has_table_response*$demo.test_profiles\x01\0\0" + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00011' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles\0\x02,no_error_if_not_exists\btrue\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/clear/table + response: + body: + string: "\x04OK\0(clear_table_response($demo.test_profiles\0\0" + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00982' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/has/table + response: + body: + string: "\x04OK\0$has_table_response*$demo.test_profiles\0\0\0" + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00009' + status: + code: 200 + message: OK +- request: + body: !!binary | + qAR7InR5cGUiOiAicmVjb3JkIiwgIm5hbWUiOiAidHlwZV9uYW1lIiwgImZpZWxkcyI6IFt7InR5 + cGUiOiAic3RyaW5nIiwgIm5hbWUiOiAidXNlcm5hbWUifSwgeyJ0eXBlIjogInN0cmluZyIsICJu + YW1lIjogIm5hbWUifSwgeyJ0eXBlIjogInN0cmluZyIsICJuYW1lIjogInNleCJ9LCB7InR5cGUi + OiAic3RyaW5nIiwgIm5hbWUiOiAiYWRkcmVzcyJ9LCB7InR5cGUiOiAic3RyaW5nIiwgIm5hbWUi + OiAibWFpbCJ9LCB7InR5cGUiOiAibG9uZyIsICJuYW1lIjogImJpcnRoZGF0ZSJ9XX0ADBB1c2Vy + bmFtZQIMY2hhcjMyAAhuYW1lAgxjaGFyMzIABnNleAIKY2hhcjEADmFkZHJlc3MCDGNoYXI2NAAI + bWFpbAIMY2hhcjMyABJiaXJ0aGRhdGUCEnRpbWVzdGFtcAAAAA== + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/create/type + response: + body: + string: !!binary | + BE9LAChjcmVhdGVfdHlwZV9yZXNwb25zZaQGKDE4MjU3ODY5MTYzMjc0NDI1MTYz8AN7InR5cGUi + OiJyZWNvcmQiLCJuYW1lIjoidHlwZV9uYW1lIiwiZmllbGRzIjpbeyJuYW1lIjoidXNlcm5hbWUi + LCJ0eXBlIjoic3RyaW5nIn0seyJuYW1lIjoibmFtZSIsInR5cGUiOiJzdHJpbmcifSx7Im5hbWUi + OiJzZXgiLCJ0eXBlIjoic3RyaW5nIn0seyJuYW1lIjoiYWRkcmVzcyIsInR5cGUiOiJzdHJpbmci + fSx7Im5hbWUiOiJtYWlsIiwidHlwZSI6InN0cmluZyJ9LHsibmFtZSI6ImJpcnRoZGF0ZSIsInR5 + cGUiOiJsb25nIn1dfQAMDmFkZHJlc3MECGRhdGEMY2hhcjY0ABJiaXJ0aGRhdGUECGRhdGESdGlt + ZXN0YW1wAAhtYWlsBAhkYXRhDGNoYXIzMgAIbmFtZQQIZGF0YQxjaGFyMzIABnNleAQIZGF0YQpj + aGFyMQAQdXNlcm5hbWUECGRhdGEMY2hhcjMyAAAAAA== + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00335' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles(18257869163274425163\b\x1Ais_replicated\nfalse$no_error_if_exists\nfalse\x1Ais_collection\nfalse6disallow_homogeneous_tables\nfalse\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/create/table + response: + body: + string: !!binary | + BE9LACpjcmVhdGVfdGFibGVfcmVzcG9uc2WmASRkZW1vLnRlc3RfcHJvZmlsZXMoMTgyNTc4Njkx + NjMyNzQ0MjUxNjMAAihxdWFsaWZpZWRfdGFibGVfbmFtZSRkZW1vLnRlc3RfcHJvZmlsZXMAAA== + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.01371' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles\x02\x12get_sizes\btrue\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/table + response: + body: + string: !!binary | + BE9LACZzaG93X3RhYmxlX3Jlc3BvbnNlghYkZGVtby50ZXN0X3Byb2ZpbGVzAiRkZW1vLnRlc3Rf + cHJvZmlsZXMAAgAAAigxODI1Nzg2OTE2MzI3NDQyNTE2MwAC8AN7InR5cGUiOiJyZWNvcmQiLCJu + YW1lIjoidHlwZV9uYW1lIiwiZmllbGRzIjpbeyJuYW1lIjoidXNlcm5hbWUiLCJ0eXBlIjoic3Ry + aW5nIn0seyJuYW1lIjoibmFtZSIsInR5cGUiOiJzdHJpbmcifSx7Im5hbWUiOiJzZXgiLCJ0eXBl + Ijoic3RyaW5nIn0seyJuYW1lIjoiYWRkcmVzcyIsInR5cGUiOiJzdHJpbmcifSx7Im5hbWUiOiJt + YWlsIiwidHlwZSI6InN0cmluZyJ9LHsibmFtZSI6ImJpcnRoZGF0ZSIsInR5cGUiOiJsb25nIn1d + fQACAAACDA5hZGRyZXNzBAhkYXRhDGNoYXI2NAASYmlydGhkYXRlBAhkYXRhEnRpbWVzdGFtcAAI + bWFpbAQIZGF0YQxjaGFyMzIACG5hbWUECGRhdGEMY2hhcjMyAAZzZXgECGRhdGEKY2hhcjEAEHVz + ZXJuYW1lBAhkYXRhDGNoYXIzMgAAAAI6ImF0dHJpYnV0ZV9pbmRleGVzACBjb2xsZWN0aW9uX25h + bWVzCGRlbW8wZGF0YXNvdXJjZV9zdWJzY3JpcHRpb25zABhmb3JlaWduX2tleXMAJGdsb2JhbF9h + Y2Nlc3NfbW9kZRRyZWFkX3dyaXRlLGlzX2F1dG9tYXRpY19wYXJ0aXRpb24KZmFsc2UQaXNfZGly + dHkAImlzX3ZpZXdfcGVyc2lzdGVkACJsYXN0X3JlZnJlc2hfdGltZQAob3duZXJfcmVzb3VyY2Vf + Z3JvdXA+a2luZXRpY2FfZGVmYXVsdF9yZXNvdXJjZV9ncm91cCpwYXJ0aXRpb25fZGVmaW5pdGlv + bnMANHBhcnRpdGlvbl9kZWZpbml0aW9uc19qc29uBHt9HHBhcnRpdGlvbl9rZXlzABxwYXJ0aXRp + b25fdHlwZQhOT05FIHByaW1hcnlfa2V5X3R5cGUMbWVtb3J5GHJlY29yZF9ieXRlcwYxNjkccmVm + cmVzaF9tZXRob2QAJnJlbWFpbmluZ190YWJsZV90dGwELTEicmVxdWVzdF9hdnJvX2pzb27iA3si + dGFibGVfbmFtZSI6ImRlbW8udGVzdF9wcm9maWxlcyIsInR5cGVfaWQiOiIxODI1Nzg2OTE2MzI3 + NDQyNTE2MyIsIm9wdGlvbnMiOnsiZGlzYWxsb3dfaG9tb2dlbmVvdXNfdGFibGVzIjoiZmFsc2Ui + LCJmb3JlaWduX2tleXMiOiIiLCJpc19jb2xsZWN0aW9uIjoiZmFsc2UiLCJpc19yZXBsaWNhdGVk + IjoiZmFsc2UiLCJub19lcnJvcl9pZl9leGlzdHMiOiJmYWxzZSIsInByaW1hcnlfa2V5X3R5cGUi + OiJtZW1vcnkifX0icmVxdWVzdF9hdnJvX3R5cGUQaXNfdGFibGUWc2NoZW1hX25hbWUIZGVtbyZz + dHJhdGVneV9kZWZpbml0aW9uUiggKCBWUkFNIDIsIFJBTSA1LCBESVNLMCA1LCBQRVJTSVNUIDUg + KSApGnRhYmxlX21vbml0b3IEe30SdGFibGVfdHRsBC0xFnRvdGFsX2J5dGVzAjA4dXNlcl9jaHVu + a19jb2x1bW5fbWF4X21lbW9yeRI1MTIwMDAwMDAqdXNlcl9jaHVua19tYXhfbWVtb3J5FDgxOTIw + MDAwMDAedXNlcl9jaHVua19zaXplDjgwMDAwMDAedmlld190YWJsZV9uYW1lAAAAAgAAAgAAAgAA + AAAAAAAAAAAAAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00283' + status: + code: 200 + message: OK +- request: + body: !!binary | + JGRlbW8udGVzdF9wcm9maWxlc8gB0gESZWR1YXJkbzY5FEhhbGV5IEJlY2sCRmg1OTgzNiBDYXJs + YSBDYXVzZXdheSBTdWl0ZSA5MzkKUG9ydCBFdWdlbmUsIElOIDMyNDg3LG1lbHRvbmRlbmlzZUB5 + YWhvby5jb22A8MKF7jLSARBsYmFycmVyYR5Kb3NodWEgU3RlcGhlbnMCTWYzMTA4IENocmlzdGlu + YSBGb3JnZXMKUG9ydCBUaW1vdGh5Y2hlc3RlciwgS1kgNzI5ODAmZXJpY2E4MEBob3RtYWlsLmNv + bf+vur7vU6gBDmJidXJ0b24YUGF1bGEgS2Fpc2VyAkY+VW5pdCA3NDA1IEJveCAzMDUyCkRQTyBB + RSAwOTg1OCx0aW1vdGh5cG90dHNAZ21haWwuY29t/9/b3NtCygESbWVsaXNzYTQ5FldlbmR5IFJl + ZXNlAkZqNjQwOCBDaHJpc3RvcGhlciBIaWxsIEFwdC4gNDU5Ck5ldyBCZW5qYW1pbiwgTkogMTUw + OTYgZGFkYW1zQGdtYWlsLmNvbYCQ/bWOItIBGm1lbGlzc2FjYXJ0ZXIWTWFudWVsIFJpb3MCTV4y + MjQxIEJlbGwgR2FyZGVucyBTdWl0ZSA3MjMKU2NvdHRzaWRlLCBDQSAzODQ2Myx3aWxsaWFtYXlh + bGFAZ21haWwuY29t/9//ptpHuAEOamFtZXMyNh5QYXRyaWNpYSBQb3R0ZXICRlA3OTc3IEpvbmF0 + aGFuIE1lYWRvdwpKZXJyeXNpZGUsIE9IIDU1MjA1JGpwYXRyaWNrQGdtYWlsLmNvbYCgj76jRtoB + IHZhbmVzc2F2YWxlbnRpbmUeQW50aG9ueSBTaW1wc29uAk1QNDA1IE1hdGhldyBJc2xhbmQKUG9y + dCBSZWJlY2NhLCBBWiAwMzEwNDRrcmlzdGluZXBhcmtlckBob3RtYWlsLmNvbf+flLmJKuIBHmFu + ZGVyc29uYnJpZGdldBxKb25hdGhhbiBQYXluZQJNZjc4MzkzIFdpbGxpYW1zIEhlaWdodHMgQXB0 + LiA3NzYKUG9ydCBMaXNhLCBHVSAxMjExMSpqYXNvbmhhcnZleUBnbWFpbC5jb23/76L1hVPEARZt + b29yZWFuZHJldxpXZW5keSBSYW1pcmV6AkZUODA4OSBHb256YWxleiBGaWVsZHMKSm9yZGFudmls + bGUsIEtTIDIyODI0KG1hdGhldzA1QGhvdG1haWwuY29tgKCXlPcz4AEYZmxveWRjeW50aGlhFEp1 + ZHkgT3J0aXoCRnA1ODk4NCBXcmlnaHQgVGhyb3VnaHdheSBTdWl0ZSA3MjUKVGltb3RoeW1vdXRo + LCBPSyAwOTEzMSxwYXR0b25lcmljQGhvdG1haWwuY29t/6+gjvAB0gESc2hhbm5vbjc0GldpbGxp + YW0gRGF2aXMCTWAxMDQgRG95bGUgSnVuY3Rpb24gQXB0LiAyMDIKRWFzdCBTdGFjeSwgTUkgOTM0 + NzMuZ3JhbnR0aG9tcHNvbkBnbWFpbC5jb22AoP+KthO+ARJsYW5lamFjb2IaQ2hlbHNlYSBXZWVr + cwJGUjMyOTEgV2lsbGlhbXMgUGxhY2UKTmV3IExpbmRzYXksIE9LIDQ0ODA1KGhoZXJuYW5kZXpA + eWFob28uY29t/5/v+M4EtgEabWVsaXNzYWJ1dGxlchZBbGV4YSBLZWxseQJGSDE5MDQgQnVya2Ug + Um9hZHMKUG9ydCBBbm5lLCBERSA4MTI1MiZkb3VnbGFzMzhAeWFob28uY29tgOCXgvVdygEMdHJv + eTkzHEV0aGFuIExhd3JlbmNlAk1qODUzNDUgRWRnYXIgRHJpdmVzIFN1aXRlIDQxMApTb3V0aCBT + aGFuZXRvbiwgTVQgMDM3NjggcHBlcmV6QGdtYWlsLmNvbYCQ3pScC8gBGmNocmlzdG9waGVyMjQW + S2VsbHkgV2F0dHMCRlIzNDkgQ2FzdHJvIEJyb29rClBvcnQgS2VsbHlidXJ5LCBORCAwMTY5NC5u + ZXd0b25hZHJpYW5hQHlhaG9vLmNvbf+/yOH0D+IBDnF3cmlnaHQcS2VsbHkgRnJhbmtsaW4CRmQ5 + OTUgR2FyY2lhIExhbmQgQXB0LiAyMjAKTm9ydGggVHJhY2V5dG9uLCBTRCA2NTk1NTxrYXRoZXJp + bmVhbGV4YW5kZXJAaG90bWFpbC5jb22AsJ+VhxrSARpuaWNvbGViYWxkd2luGkFuZ2VsYSBIb3J0 + b24CRlAxMTgyNyBKZXNzaWNhIEZvcnQKTGFrZSBNb3JnYW4sIE1TIDE4OTA1NndpbGxpYW1zcmVi + ZWNjYUBob3RtYWlsLmNvbf+Poen5IdgBDmJyaWFuMTIiU3RlZmFuaWUgV2lsbGlhbXMCRmQ2ODc3 + MiBCcml0dGFueSBJc2xlIFN1aXRlIDMzMwpIb3J0b25iZXJnLCBPUiA5NTg3MSxncmFoYW1qYXNt + aW5AZ21haWwuY29t/5+RoKhotAEQemhhcmRpbmccQnJhbmRvbiBNb3Jlbm8CTUoxODc2NCBPbHNv + biBHYXJkZW5zClJpY2V0b24sIEFTIDIyNjg5JnpjYXN0aWxsb0BnbWFpbC5jb22AsJfj5hfMAQxz + bWNrZWUYRXJpY2EgUm9tZXJvAkZsNDA4MDEgU255ZGVyIEdhcmRlbiBTdWl0ZSA2MzIKTmV3IFNh + bXVlbGxhbmQsIE1QIDU3MjA4JHRhbWFyYTc5QHlhaG9vLmNvbf/vz/etKNoBFG1mcmVkZXJpY2se + S2V2aW4gU3RldmVuc29uAk1kNzgzODUgTWljaGVsbGUgQ3Jvc3Nyb2FkCkVhc3QgSmFtZXNidXJn + aCwgRk0gMjcyODcsYW5kcmV3amVuc2VuQHlhaG9vLmNvbYCQzrehXpQBFGtpbWJlcmx5NjYWTWFy + aWEgV29vZHMCRixVU05WIEJlbGwKRlBPIEFFIDc3NTcxJmplc3VzNDZAaG90bWFpbC5jb23/3/vs + wyK6AQx6bnVuZXoaVGltb3RoeSBLaXJieQJNWDc0NTAgV2FnbmVyIFZpYSBTdWl0ZSA0NDkKTGVl + dmlsbGUsIE5DIDQ4NzEwJmRvdWdsYXM0MUB5YWhvby5jb23/n7vhIrABCGhsZWUQTGVlIFJpY2UC + TVAzMjMgU3BlbmNlciBSaXZlcgpOb3J0aCBBc2hsZXksIE9IIDM5Mzc1MHNoZWxieWdyZWVuZUBo + b3RtYWlsLmNvbYCA9dixJ6gBEmJyb3duYW5uYRpKZW5uaWZlciBSb3dlAkY+VW5pdCA3NjgwIEJv + eCA3NzEzCkRQTyBBRSA4NzQ4MiZyZWJlY2NhOTlAeWFob28uY29tgPClxoA+0AEQa3Jvc2FyaW8g + TmljaG9sYXMgQ2Fycm9sbAJNYDE5NCBFZHdhcmRzIEhvbGxvdwpFYXN0IFN0ZXBoZW5jaGVzdGVy + LCBQUiA0MzI3NyhtYW51ZWw2NUBob3RtYWlsLmNvbYCg/JWIPcYBGGxhdXJhbWF5bmFyZBZFbWls + eSBBbGxlbgJGYDIwNSBGbG9yZXMgTWVhZG93IFN1aXRlIDkwNwpMYWtlIEtldmluLCBISSAxMjQ0 + NyB2YnVybnNAZ21haWwuY29tgODIvrNY2gEUZXJpY2Rlbm5pcx5IZWF0aGVyIEphY2tzb24CRmQz + NDUwIE1pZGRsZXRvbiBXYWxrIFN1aXRlIDg1MApMYWtlIEVyaWNhLCBNVCA0MDg0Nyx3aGl0ZW5h + bmN5QGhvdG1haWwuY29tgJDMhvANugEQcXNhbmNoZXoaSm9obiBXaWxsaWFtcwJNVjgzNTIgQWd1 + aWxhciBTcXVhcmUKSG93YXJkYm9yb3VnaCwgQ1QgMTYyODAiaXRvcnJlc0BnbWFpbC5jb22A8KzU + vhXIAQxoc21pdGgYQWxsZW4gV2Fsa2VyAk1qODIxMDMgVHJhY3kgR2xlbnMgU3VpdGUgNDI5Ckxh + a2UgS2F0aWVzaGlyZSwgR1UgOTI0MDQiZWhhcnJpc0BnbWFpbC5jb23/75XYzBrCAQ5lZGFuaWVs + GkRvbmFsZCBIZXN0ZXICTVY4NTM0IE1lbGVuZGV6IEdyZWVucwpCZW5uZXR0bW91dGgsIE1IIDY5 + OTM5LGpvc2h1YW9icmllbkBnbWFpbC5jb23//8310WC8ARpoaWdnaW5zcm9iZXJ0Gk1hcnkgUmlj + aGFyZHMCRko3NDIgTWlyYW5kYSBMb2NrcwpFYXN0IExpc2EsIFNEIDM5MjgwJnhoYW5zZW5AaG90 + bWFpbC5jb22AkMvIzRa+ARZncmFudGhvcnRvbhpNZWxpc3NhIERpeG9uAkZQOTk0MCBCdWNoYW5h + biBUcmFpbApQZXRlcnNzdGFkLCBPUiA5OTg4MyZ2bWl0Y2hlbGxAZ21haWwuY29tgODI1cZdzAEQ + c2hlaWxhMjIiVHJldm9yIFZhbGVuenVlbGECTWA4MDYgTWFzb24gQ2lyY2xlcyBTdWl0ZSAwMjIK + U2FtdWVsdG93biwgQVMgNTYyOTAiaG9sbHk3NEBnbWFpbC5jb22AsP+bsj+sAQxnaW5hMzQgVGlt + b3RoeSBNYXJzaGFsbAJNPjUxNyBDb3ggUnVlCk1leWVyYnVyeSwgSUwgMDc5MDAqbWVsdmluc21p + dGhAeWFob28uY29tgODtm9sR6gEUam9uZXN3YW5kYSZBbGV4aXMgTWFydGluZXogRERTAk12NzE4 + MjEgVG9ycmVzIEhhcmJvcnMgU3VpdGUgOTI2Ck5vcnRoIERhdmlkY2hlc3RlciwgTUQgOTkxNjUk + bWZyb3N0QGhvdG1haWwuY29t/9/B8RXMAQx2bWNjb3kcTWljaGFlbCBLZWxsZXkCTVo4NTA2IE1h + cmN1cyBVbmlvbnMKRWFzdCBBbmRyZXdoYXZlbiwgRkwgMTk4NDcyYmxha2VtYXJnYXJldEBob3Rt + YWlsLmNvbf+v69mnKtYBGGhlbnJ5Y29sbGlucxxEYXJsZW5lIE11cnJheQJGZDM5MDMgUmhvZGVz + IFR1cm5waWtlIFN1aXRlIDI4OApCdXJuc2xhbmQsIFdJIDkyMTIzJmplYW5iYXRlc0BnbWFpbC5j + b23/v9iK7yPQARRqZW5uaWZlcjQ4Fkphc29uIFBlcmV6Ak1YNTgxOCBEb3VnaGVydHkgRmllbGRz + ClZhbmVzc2Ftb3V0aCwgTkUgMjU5MDQ2cGhpbGxpcHN0aW1vdGh5QGhvdG1haWwuY29tgOD6uJRK + 0AEUZ2FyeXRvcnJlcxxKZXN1cyBSaW9zIEpyLgJNZjMyNjgwIEZlcmd1c29uIFNxdWFyZXMgQXB0 + LiAzNTQKSm9obmJ1cmdoLCBDQSA0NjQ2OCJjaW5keTQ4QHlhaG9vLmNvbYCQv+aJDsgBCmtyZWVk + Ik1pY2hhZWwgUm9kcmlndWV6Ak1gOTU5NTUgRXJpYyBSb2FkIEFwdC4gMjA1ClN0ZXZlbmJvcm91 + Z2gsIEFaIDc5MDEzJGtyb2FjaEBob3RtYWlsLmNvbYDgv//DMNABGnJpY2hhcmRtYXJ0aW4WRG9u + YWxkIEh1bnQCTVgzMzE0MyBCYWtlciBTaG9yZQpFYXN0IFJvYmVydHZpbGxlLCBDTyA1MjA1NTBo + aW5lc3ZhbmVzc2FAaG90bWFpbC5jb22AwLb+wVXiARplcmlrYXJleW5vbGRzHENhcnJpZSBTaGVs + dG9uAkZoNDgzMDkgTWlzdHkgUGFyayBTdWl0ZSAwMzkKTmV3IFJvYmVydGJ1cmdoLCBOTSA1MjY2 + OSx0ZXJyaXdhbGxhY2VAeWFob28uY29tgJCj/NEV0AEadmljdG9yaWFtb29yZR5DaHJpc3R5IEpv + aG5zb24CRloxNjQ0MSBBbmdlbGEgSnVuY3Rpb24KTm9ydGggQ3J5c3RhbCwgT1IgMjU3MzAmbGVl + cmFjaGVsQHlhaG9vLmNvbf+vkaDrHa4BEnN1c2Fucm9zZRhNYXJpYSBQYXJrZXICRk45OTMgUm9i + aW5zb24gU2hvcmVzCkxha2UgTG9yaSwgTkogOTUyNzIeYXNoYXdAZ21haWwuY29tgNCOyZwP1gEQ + c2FyYWR1a2UcVGhvbWFzIFJ1c3NlbGwCTWg1MDA4MCBEYXZpZCBEcml2ZSBBcHQuIDgxOApQb3J0 + IFJpY2tleWJ1cnksIEFTIDQwNjk2KmdyaWNoYXJkc29uQHlhaG9vLmNvbYCQhduOPtIBFGJyZW50 + c21pdGgaTWljaGFlbCBMb3BlegJNZDY0MyBFcmljYSBTdHJhdmVudWUgU3VpdGUgNzU5Ck5ldyBC + cm9va2UsIElBIDkwNzA3KGtlbGx5ZGF2aWRAZ21haWwuY29tgNChtvEn2AEOdHJhY3k1MxpDaGVs + c2VhIFNpbmdoAkZkNjIyNDcgTWNpbnR5cmUgQ2VudGVyIEFwdC4gNDI5CkZvbGV5cG9ydCwgTk0g + MjMyNzI0dmVsYXpxdWV6Y2FpdGxpbkB5YWhvby5jb23/j9rKuDiyAQ5yYWxwaDI1GExhdXJhIE5l + bHNvbgJGUjE4MjggQ2FzdGlsbG8gUG9pbnRzCkxha2UgTmFuY3ksIE5ZIDk1ODAwInZ3aWxzb25A + eWFob28uY29tgODv/d8zmAESdG9kZGFsbGVuGkpvaG4gTWFyc2hhbGwCTTBVU1MgUnVzc2VsbApG + UE8gQUEgMTgxNjMkZWdvb2R3aW5AeWFob28uY29t/8+izbNsyAEQbmF0aGFuNjMYU3RhY2V5IEhh + cmR5AkZkNDE2NCBNb3JhbiBQYXRoIFN1aXRlIDcwOQpXZXN0IEd3ZW5kb2x5biwgVE4gMDc0ODYk + YWx5c3NhMzZAeWFob28uY29t/5+u4sIk8AEccGFtZWxhcmljaGFyZHMwRHIuIE5hdGhhbmllbCBD + YXJ0ZXIgRFZNAk1iNjcwIFJvbWFuIEdyZWVucyBTdWl0ZSA4NDIKU2ltbW9uc2hhdmVuLCBDQSA4 + MzM4OSpza2lubmVyam9obkBnbWFpbC5jb23/75mS4z/SARpzdGFjeWNhbGRlcm9uIExhcnJ5IEhh + cnJpbmd0b24CTVI0NDQ5OCBIaWxsIEdyZWVuClNvdXRoIFBhdHJpY2lhLCBXQSA2NDY2Mi5jYXRo + ZXJpbmU4OEBob3RtYWlsLmNvbf/fzNfDWegBHGNhbWVyb25lbGxpb3R0HFRpbW90aHkgV2Fsa2Vy + Ak1wOTE2NzMgRWRkaWUgU2hvcmVzIFN1aXRlIDczNwpTb3V0aCBNaWNoYWVsc3RhZCwgTkMgMzIz + NTgodnNhbmNoZXpAaG90bWFpbC5jb23/393V82msAQ5kb25uYTY1GERhbmllbCBZYXRlcwJNPlVu + aXQgMjgwOSBCb3ggNDE2NwpEUE8gQVAgMTI3NTIwY2hhZG1jbGF1Z2hsaW5AZ21haWwuY29t//+W + sd5cxgEaamVubmlmZXJhbGxlbhpEb25hbGQgTWlsbGVyAk1INzc0IExvcGV6IFdlbGwKTG9yaWNo + ZXN0ZXIsIEFSIDc5NTk4MmRhdmlkZmF1bGtuZXJAaG90bWFpbC5jb22AgLje4g/UAQ5ob2xseTk2 + HlN0ZXZlbiBDYW1wYmVsbAJNYDg4MjQgRG91Z2xhcyBDbHViIFN1aXRlIDg1MwpBbHlzc2FmdXJ0 + LCBNSSAyNTEyMjBodW50ZXJzdGV2ZW5AaG90bWFpbC5jb23/z86r+RbKARRrZXZpbmdyZWVuGlNo + YW5lIENoYXBtYW4CTVY4MzMgU3RlZWxlIEV4dGVuc2lvbnMKQ2FicmVyYWJ1cnksIFJJIDY2MDQ0 + LmplcmVteWpvaG5zb25AeWFob28uY29tgOCvm4Ms2gEYZ2FyeW1pdGNoZWxsGlJhbHBoIEphY2tz + b24CTWI1MzQ4IFdyaWdodCBXZWxscyBBcHQuIDMxNwpNaWNoZWxsZWZ1cnQsIE5FIDIyNTg0LmJy + aWFuZGVsZW9uQGhvdG1haWwuY29tgKDfzKcp0AEYcGFycmlzaGtheWxhFkpvaG4gRmllbGRzAk1o + MDY0IERhbmllbCBWaXN0YSBBcHQuIDY4NApXZXN0IFJpY2hhcmRzaWRlLCBEQyA2MzM0MSJrZWxs + eTUyQGdtYWlsLmNvbYDwpdDzXOQBHmNhc3RpbGxvY2FtZXJvbhpCcm9va2UgSGFybW9uAkZyMzgz + OTkgQ29jaHJhbiBDb3VydHMgQXB0LiA2ODkKV2VzdCBNaWNoZWxsZXZpZXcsIEFaIDgzMzQzInlj + aGF2ZXpAZ21haWwuY29tgPC078sSwAEOaG9icmllbhZQZXRlciBNZXllcgJNYjEwOCBNZWxpc3Nh + IEJ5cGFzcyBBcHQuIDY2NApQaGlsaXB2aWxsZSwgUkkgNzg1MDUiYW1iZXIyMkBnbWFpbC5jb23/ + 7/PYvzK8AQxyc21pdGgYRXJpYyBIYXdraW5zAk1eMDM5MTIgSm9uZXMgUGF0aCBTdWl0ZSA5NjQK + RWFzdCBEYXZpZCwgR1UgNTAwMDUiYWFyb243OEBnbWFpbC5jb23/n5G3u23SARZhbGV4YW5kZXI0 + MBhUaW5hIFJhbWlyZXoCRmQxMjIgU3VtbWVycyBSYW5jaCBTdWl0ZSAzODkKTm9ydGggUm9iZXJ0 + LCBORSA4NDgzNihrZWxseXNhcmFoQGdtYWlsLmNvbf+vopSoD7IBDmxhdXJhNjMaTWFydGluIEty + YW1lcgJNUDkxODIgU3VzYW4gU3RhdGlvbgpNZWxpc3Nhc3RhZCwgS1kgNzY4NzEicXRheWxvckBn + bWFpbC5jb23/j/qpzUbEAQxjYXJsMTkYQW1hbmRhIFBvdHRzAkZkOTg5OTQgQ2xhcmtlIENpcmNs + ZSBBcHQuIDc1NQpNb3JhbGVzcG9ydCwgQ1QgMjcxMTckbmNvY2hyYW5AeWFob28uY29t/9+Q07Bi + tAEOdGFtbXk1OBpKb25hdGhhbiBNYXlvAk1SNTc0NjMgU2ltcHNvbiBXYWxrClJhbWlyZXp2aWxs + ZSwgV1kgMzMwNTUibGF1cmEzMkB5YWhvby5jb22A0IT3gzP2AR5jb2xsaW5zbWljaGVsbGUgSGVh + dGhlciBDYWxsYWhhbgJGajI3MiBGb2xleSBWYWxsZXkgU3VpdGUgMzQyClBvcnQgQ2hhcmxlc3Np + ZGUsIE1PIDExNDQyNnN0ZXBoYW5pZWFybm9sZEBob3RtYWlsLmNvbf+PhaP1FLwBEGZveHRvbnlh + FEpvaG4gUmV5ZXMCTVIyNTA4NSBKYXNtaW5lIExvY2tzCldlc3QgQnJpYW5hLCBBTCAzNTk5MS5t + YXR0aGV3Y29vcGVyQGdtYWlsLmNvbYDAi6zfB74BHHJob25kYXJpY2hhcmRzGEFuZHJldyBNb29y + ZQJNUjI0MSBXaWxsaWFtcyBPcmNoYXJkClN0b2tlc3N0YWQsIElBIDE1NTIzIHdyYW1vc0BnbWFp + bC5jb22A4J/E4g3kARx3aWxsaWFtbmljaG9scxZMYXVyYSBTdG9uZQJGbDY3MjIgQ2hyaXN0b3Bo + ZXIgU3F1YXJlClBvcnQgQ2hyaXN0b3BoZXJ2aWV3LCBQQSA1OTg3Mi5tb3JyaXNtZWxhbmllQGdt + YWlsLmNvbYCg//OiDswBEGFuZHJldzI0FlJvZG5leSBUb2RkAk1wNTk0NjUgQnJlbmRhIFNwdXJz + IEFwdC4gMjE3Cldlc3QgQ2hyaXN0aW5hYnVyeSwgU0QgMzgwMjceYW15MDlAZ21haWwuY29tgNDA + wNA5zgEQa3lsZWJlbGwWR2VvcmdlIFlhbmcCTWA0NjA4MSBIYW5uYWggVHJhaWwgU3VpdGUgNDEx + Ckxha2UgQ29yeSwgQVIgNjIwNTcwbW9saW5hdGF5bG9yQGhvdG1haWwuY29t/6+p7uVN0AEOd2Fu + ZGE5OR5KZXNzaWNhIEhlcnJlcmECRmQ5Njc5IFRob21hcyBWaWxsYWdlIEFwdC4gNjI0Cldlc3Qg + VGF5bG9yLCBLWSA1Njc5OShyb2JlcnQyMUBob3RtYWlsLmNvbf+f093DOsABDnltb2xpbmEcQW5n + ZWxhIFN1bW1lcnMCRl42MjUwIEdyYW50IEdyZWVuIEFwdC4gOTU1Ck5pY29sZW1vdXRoLCBNUCAx + MjU1OSBlcmluMzhAZ21haWwuY29t/8/C545r2AESYWRyaWFuYTAyGERhdmlkIE1vcmdhbgJNajk4 + MzE0IFNtaXRoIEZvcmQgU3VpdGUgNTA2ClNvdXRoIFdhcnJlbnNpZGUsIEFMIDE0MTgxLGJyb3du + Y2xheXRvbkBnbWFpbC5jb22AoOqhnAzUARJ3aWxsaWFtNTceRWxpemFiZXRoIFdlbGxzAkZgMDQ4 + OSBTdGFjeSBTaG9hbHMgQXB0LiAwMTEKQXJ0aHVybW91dGgsIE1UIDUxNjU5LHJhbWlyZXpiaWxs + eUBnbWFpbC5jb22A4M2s+VW4AQxkbW9yYW4eQXNobGV5IEpvaG5zdG9uAkZUMDUxNTEgVmVyb25p + Y2EgTWlzc2lvbgpBbWJlcnRvd24sIE9IIDAyOTExInl3aWxzb25AZ21haWwuY29t/7+nxL0KxAEc + amFja3Nvbmtlbm5ldGgcTWljaGVhbCBNdXJwaHkCTVIzNjYxIENhcmxzb24gSXNsYW5kClNvdXRo + IERhdmlkLCBGTSAwOTYzNyJhcml2ZXJhQGdtYWlsLmNvbf+fifunTMgBEmJyaWRnZXQ1OBhEYXZp + ZCBNaWxsZXICTWAzNjY4IEhlbGVuIFBsYWlucyBBcHQuIDY5MgpOZXcgQnJpZGdldCwgTkggNjA0 + NzUmZnJhbmtob29kQHlhaG9vLmNvbYCQsMexWN4BGGFwcmlsamltZW5lehhHcmVnb3J5IEhvbHQC + TWQ0NTI3IEplZmZyZXkgQ2lyY2xlcwpMYWtlIEVsaXphYmV0aHNoaXJlLCBBSyAxNzgyODJnYXJj + aWFkb3VnbGFzQGhvdG1haWwuY29t/4+l/9xbxAEgbWFyZ2FyZXRtYXJ0aW5lehxDbGlmZm9yZCBC + YWtlcgJNTDI5MTEzIFRob21hcyBSb3V0ZQpNYXlvaGF2ZW4sIE1EIDYwMjE3JGpwZXJraW5zQGdt + YWlsLmNvbYDwwNGPG+IBEGxlZHdhcmRzJk1ycy4gSnVsaWUgQnJhZHNoYXcCRmg1Njg3IFdpbnRl + cnMgSG9sbG93IEFwdC4gMzQ0Cldlc3QgQmVuamFtaW4sIFJJIDcxMDY4LG9kb25uZWxsdG9ueUB5 + YWhvby5jb23//6LetQPIAQ5sYXVyYTI4GERvbm5hIE1hZGRlbgJGYDE5MjAgTmljaG9scyBEYWxl + IFN1aXRlIDI2NApCcm93bmJ1cmdoLCBNVCA3OTM1OCp0aW1vdGh5aGlsbEBnbWFpbC5jb23//4fn + jGTgARZodWZmbWF1cmVlbiBBbnRob255IE1hcnRpbmV6Ak1gNDcyNCBNZWx2aW4gTG9vcCBTdWl0 + ZSAxNzAKRmlubGV5dmlsbGUsIE5KIDI5NjExMmNocmlzdG9waGVyOTdAaG90bWFpbC5jb23/v+3C + tVnMARh3YWx0ZXJzZGF2aWQkU2FtYW50aGEgTGV3aXMgRERTAkZOOTQ1MiBPc2Jvcm5lIExpZ2h0 + cwpFdmVseW50b24sIE1BIDc0MjMzKnJlYmVrYWgzMkBob3RtYWlsLmNvbYCAkq+yIdoBGGFsbGVu + amFzbWluZR5Kb3NodWEgV2lsbGlhbXMCTV4wMTEzNyBMaXNhIElzbGFuZHMgU3VpdGUgMDE3CkJp + bGxiZXJnLCBPUiAxNzI4MC5zdXNhbm1hcnRpbmV6QGdtYWlsLmNvbf+/tYXZbcIBHGtyaXN0aW5i + YXJuZXR0HkRlYm9yYWggV2FsbGFjZQJGSjc3NzM3IEhpY2tzIExvYWYKQ2FycmlldG93biwgREUg + MTQ2MjYmcGF0cmljazgyQGdtYWlsLmNvbYCQ/fDUErgBFmhhcnJpc3NhcmFoHEFudGhvbnkgSGVu + c29uAk1ONDMzNTQgQXNobGV5IExhbmQKV2VzdCBKb3NodWEsIE5ZIDg3NjExInh3YXRzb25AZ21h + aWwuY29t//+ghiTWAR5zYW11ZWxyb2RyaWd1ZXoYUm9iZXJ0IEFkYW1zAk1mMTY0IEhheWVzIEV4 + dGVuc2lvbnMgQXB0LiAyNTEKVG9ycmVzbW91dGgsIERFIDc3NDUwImRjaGF2ZXpAZ21haWwuY29t + gNCPyctOsAEMbGhlbnJ5GEVyaW4gQmFyYWphcwJGUDA4OTggVGF5bG9yIFJhZGlhbApHYXJkbmVy + c3RhZCwgT1IgNDg5NDIkaWZyZWVtYW5AeWFob28uY29tgJD7w7xSxgEYY2xhcmttYXR0aGV3Gkp1 + bGllIENvbGxpbnMCRlQ4OTEgRGVhbiBDbHViCldlc3QgR2VvcmdlYm9yb3VnaCwgUFIgODkxMDEo + d2VzbGV5NzlAaG90bWFpbC5jb22AkKKnnBm6ARRnb21lemVkd2luHk5pY2hvbGFzIFRob21hcwJN + UDk4NiBLYXRocnluIEN1cnZlClNvdXRoIExhdXJlbiwgS1MgMDgwNTYgeWxld2lzQHlhaG9vLmNv + bYCgrsuvH6oBDGpzaG9ydBpCZWNreSBKb2huc29uAkZKNDk5MCBDb2xpbiBTcHVyCkpvaG5zb25i + ZXJnLCBJTiAwNTU2OCJhbWFsb25lQGdtYWlsLmNvbf/PoIy1bsgBFmRhdmlkZ3JpbWVzFEphbmV0 + IExhcmECRl42NTU5NiBHYXJjaWEgRmllbGRzClBvcnQgRGF2aWRjaGVzdGVyLCBOViAwNjYzOCht + ZXJlZGl0aDEwQHlhaG9vLmNvbYDQ7umHAdYBGGJhbGxhcmRzdXNhbhpTY290dCBGcmF6aWVyAk1g + Njg1IEplbm55IFNob3JlIEFwdC4gMTczClN0YWNleWNoZXN0ZXIsIEtTIDA0NDcyLGxhdXJhZ2Fy + ZG5lckB5YWhvby5jb22A8JOKrja2ARxjaGVsc2VhYWd1aXJyZRRHYXJ5IFd5YXR0Ak1KOTkxIEJl + bmRlciBDb3ZlcwpFYXN0IE1pc3R5LCBNRCA0MjE5MSR5cmljaGFyZEBnbWFpbC5jb22AwI6e4Bbg + ASJlbGl6YWJldGhyb2JpbnNvbhhEYXZpZCBMYXJzb24CTWg3MTU1MCBKZW5uaWZlciBMaWdodHMg + U3VpdGUgMzY3CkdhcmNpYWZ1cnQsIE1BIDA3Mjg0JnNhcmFoNTVAaG90bWFpbC5jb22A0LrFuxbW + ARhqYWNxdWVsaW5lMjcSTWFyeSBTb3RvAkZkMDA2OSBIZXJuYW5kZXogQnJvb2sgQXB0LiA1MDcK + SGFyb2xkcG9ydCwgTkQgMDk0NjAwYmFsZHdpbmtlbGx5QGhvdG1haWwuY29t///nlJg8xAEKcnJv + c2UYQ29keSBTcGVuY2VyAk1kMDU3MTMgTWlsbGVyIFVuaW9uIEFwdC4gOTQ3ClphY2hhcnltb3V0 + aCwgTUEgMDIwNjkmZHJvYmluc29uQHlhaG9vLmNvbf/voKqUNgAADGJpbmFyeQA= + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/insert/records + response: + body: + string: !!binary | + BE9LAC5pbnNlcnRfcmVjb3Jkc19yZXNwb25zZQoAyAEAAAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:35 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00419' + status: + code: 200 + message: OK +- request: + body: "$demo.test_profiles\x02\x12get_sizes\btrue\0" + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/show/table + response: + body: + string: !!binary | + BE9LACZzaG93X3RhYmxlX3Jlc3BvbnNlihYkZGVtby50ZXN0X3Byb2ZpbGVzAiRkZW1vLnRlc3Rf + cHJvZmlsZXMAAgAAAigxODI1Nzg2OTE2MzI3NDQyNTE2MwAC8AN7InR5cGUiOiJyZWNvcmQiLCJu + YW1lIjoidHlwZV9uYW1lIiwiZmllbGRzIjpbeyJuYW1lIjoidXNlcm5hbWUiLCJ0eXBlIjoic3Ry + aW5nIn0seyJuYW1lIjoibmFtZSIsInR5cGUiOiJzdHJpbmcifSx7Im5hbWUiOiJzZXgiLCJ0eXBl + Ijoic3RyaW5nIn0seyJuYW1lIjoiYWRkcmVzcyIsInR5cGUiOiJzdHJpbmcifSx7Im5hbWUiOiJt + YWlsIiwidHlwZSI6InN0cmluZyJ9LHsibmFtZSI6ImJpcnRoZGF0ZSIsInR5cGUiOiJsb25nIn1d + fQACAAACDA5hZGRyZXNzBAhkYXRhDGNoYXI2NAASYmlydGhkYXRlBAhkYXRhEnRpbWVzdGFtcAAI + bWFpbAQIZGF0YQxjaGFyMzIACG5hbWUECGRhdGEMY2hhcjMyAAZzZXgECGRhdGEKY2hhcjEAEHVz + ZXJuYW1lBAhkYXRhDGNoYXIzMgAAAAI6ImF0dHJpYnV0ZV9pbmRleGVzACBjb2xsZWN0aW9uX25h + bWVzCGRlbW8wZGF0YXNvdXJjZV9zdWJzY3JpcHRpb25zABhmb3JlaWduX2tleXMAJGdsb2JhbF9h + Y2Nlc3NfbW9kZRRyZWFkX3dyaXRlLGlzX2F1dG9tYXRpY19wYXJ0aXRpb24KZmFsc2UQaXNfZGly + dHkAImlzX3ZpZXdfcGVyc2lzdGVkACJsYXN0X3JlZnJlc2hfdGltZQAob3duZXJfcmVzb3VyY2Vf + Z3JvdXA+a2luZXRpY2FfZGVmYXVsdF9yZXNvdXJjZV9ncm91cCpwYXJ0aXRpb25fZGVmaW5pdGlv + bnMANHBhcnRpdGlvbl9kZWZpbml0aW9uc19qc29uBHt9HHBhcnRpdGlvbl9rZXlzABxwYXJ0aXRp + b25fdHlwZQhOT05FIHByaW1hcnlfa2V5X3R5cGUMbWVtb3J5GHJlY29yZF9ieXRlcwYxNjkccmVm + cmVzaF9tZXRob2QAJnJlbWFpbmluZ190YWJsZV90dGwELTEicmVxdWVzdF9hdnJvX2pzb27iA3si + dGFibGVfbmFtZSI6ImRlbW8udGVzdF9wcm9maWxlcyIsInR5cGVfaWQiOiIxODI1Nzg2OTE2MzI3 + NDQyNTE2MyIsIm9wdGlvbnMiOnsiZGlzYWxsb3dfaG9tb2dlbmVvdXNfdGFibGVzIjoiZmFsc2Ui + LCJmb3JlaWduX2tleXMiOiIiLCJpc19jb2xsZWN0aW9uIjoiZmFsc2UiLCJpc19yZXBsaWNhdGVk + IjoiZmFsc2UiLCJub19lcnJvcl9pZl9leGlzdHMiOiJmYWxzZSIsInByaW1hcnlfa2V5X3R5cGUi + OiJtZW1vcnkifX0icmVxdWVzdF9hdnJvX3R5cGUQaXNfdGFibGUWc2NoZW1hX25hbWUIZGVtbyZz + dHJhdGVneV9kZWZpbml0aW9uUiggKCBWUkFNIDIsIFJBTSA1LCBESVNLMCA1LCBQRVJTSVNUIDUg + KSApGnRhYmxlX21vbml0b3IEe30SdGFibGVfdHRsBC0xFnRvdGFsX2J5dGVzAjA4dXNlcl9jaHVu + a19jb2x1bW5fbWF4X21lbW9yeRI1MTIwMDAwMDAqdXNlcl9jaHVua19tYXhfbWVtb3J5FDgxOTIw + MDAwMDAedXNlcl9jaHVua19zaXplDjgwMDAwMDAedmlld190YWJsZV9uYW1lAAAAAsgBAALIAQAC + AAAAAAAAAAAAyAHIAQAA + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.00293' + status: + code: 200 + message: OK +- request: + body: !!binary | + 6AUKICAgICAgICBDUkVBVEUgT1IgUkVQTEFDRSBDT05URVhUIGRlbW8udGVzdF9sbG1fY3R4CiAg + ICAgICAgKAogICAgICAgICAgICBUQUJMRSA9IGRlbW8udGVzdF9wcm9maWxlcwogICAgICAgICAg + ICBDT01NRU5UID0gJ0NvbnRhaW5zIHVzZXIgcHJvZmlsZXMuJwogICAgICAgICksCiAgICAgICAg + KAogICAgICAgICAgICBTQU1QTEVTID0gKAogICAgICAgICAgICAnSG93IG1hbnkgbWFsZSB1c2Vy + cyBhcmUgdGhlcmU/JyA9IAogICAgICAgICAgICAnc2VsZWN0IGNvdW50KDEpIGFzIG51bV91c2Vy + cwogICAgICAgICAgICBmcm9tIGRlbW8udGVzdF9wcm9maWxlcwogICAgICAgICAgICB3aGVyZSBz + ZXggPSAnJ00nJzsnKQogICAgICAgICkKICAgICAgICAAnZwBDGJpbmFyeQAAAA== + headers: + Accept: + - application/octet-stream + Content-type: + - application/octet-stream + authorization: + - DUMMY + method: POST + uri: http://172.31.33.30:9191/execute/sql + response: + body: + string: !!binary | + BE9LAChleGVjdXRlX3NxbF9yZXNwb25zZeoFAvYDeyJuYW1lIjoiZ2VuZXJpY19yZXNwb25zZSIs + InR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJjb2x1bW5fMSIsInR5cGUiOnsidHlw + ZSI6ImFycmF5IiwiaXRlbXMiOiJzdHJpbmcifX0seyJuYW1lIjoiY29sdW1uX2hlYWRlcnMiLCJ0 + eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19LHsibmFtZSI6ImNvbHVtbl9k + YXRhdHlwZXMiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn19XX0kAAIK + ZHVtbXkAAgxzdHJpbmcAAAEAAAggWC1LaW5ldGljYS1Hcm91cAZEREwKY291bnQCMBpsYXN0X2Vu + ZHBvaW50MC9jcmVhdGUvY29udGV4dC9pbnRlcm5hbC50b3RhbF9udW1iZXJfb2ZfcmVjb3JkcwIw + AAA= + headers: + Access-Control-Allow-Origin: + - '*' + Access-Control-Expose-Headers: + - x-request-time-secs + Connection: + - Close + Content-Type: + - application/octet-stream + Date: + - Thu, 22 Feb 2024 00:26:36 GMT + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Kinetica-Group: + - DDL + X-XSS-Protection: + - 1; mode=block + x-request-time-secs: + - '0.01522' + status: + code: 200 + message: OK +version: 1 diff --git a/libs/community/tests/integration_tests/chat_models/test_kinetica.py b/libs/community/tests/integration_tests/chat_models/test_kinetica.py new file mode 100644 index 0000000000..05f55e7a6b --- /dev/null +++ b/libs/community/tests/integration_tests/chat_models/test_kinetica.py @@ -0,0 +1,201 @@ +"""Test Kinetica Chat API wrapper.""" + +import logging +from typing import TYPE_CHECKING, Generator + +import pandas as pd +import pytest +from langchain_core.messages import ( + AIMessage, + HumanMessage, + SystemMessage, +) +from langchain_core.prompts import ChatPromptTemplate + +from langchain_community.chat_models.kinetica import ( + ChatKinetica, + KineticaSqlOutputParser, + KineticaSqlResponse, + KineticaUtil, +) + +if TYPE_CHECKING: + import gpudb + + +LOG = logging.getLogger(__name__) + + +@pytest.fixture(scope="module") +def vcr_config() -> dict: + return { + # Replace the Authorization request header with "DUMMY" in cassettes + "filter_headers": [("authorization", "DUMMY")], + } + + +class TestChatKinetica: + """Integration tests for `Kinetica` chat models. + + You must have `gpudb`, `typeguard`, and `faker` packages installed to run these + tests. pytest-vcr cassettes are provided for offline testing. + + For more information see https://docs.kinetica.com/7.1/sql-gpt/concepts/. + + These integration tests follow a workflow: + + 1. The `test_setup()` will create a table with fake user profiles and and a related + LLM context for the table. + + 2. The LLM context is retrieved from the DB and used to create a chat prompt + template. + + 3. A chain is constructed from the chat prompt template. + + 4. The chain is executed to generate the SQL and execute the query. + """ + + table_name = "demo.test_profiles" + context_name = "demo.test_llm_ctx" + num_records = 100 + + @classmethod + @pytest.mark.vcr() + def test_setup(cls) -> "gpudb.GPUdb": + """Create the connection, test table, and LLM context.""" + + kdbc = KineticaUtil.create_kdbc() + cls._create_test_table(kdbc, cls.table_name, cls.num_records) + cls._create_llm_context(kdbc, cls.context_name) + return kdbc + + @pytest.mark.vcr() + def test_create_llm(self) -> None: + """Create an LLM instance.""" + import gpudb + + kinetica_llm = ChatKinetica() + LOG.info(kinetica_llm._identifying_params) + + assert isinstance(kinetica_llm.kdbc, gpudb.GPUdb) + assert kinetica_llm._llm_type == "kinetica-sqlassist" + + @pytest.mark.vcr() + def test_load_context(self) -> None: + """Load the LLM context from the DB.""" + kinetica_llm = ChatKinetica() + ctx_messages = kinetica_llm.load_messages_from_context(self.context_name) + + system_message = ctx_messages[0] + assert isinstance(system_message, SystemMessage) + + last_question = ctx_messages[-2] + assert isinstance(last_question, HumanMessage) + assert last_question.content == "How many male users are there?" + + @pytest.mark.vcr() + def test_generate(self) -> None: + """Generate SQL from a chain.""" + kinetica_llm = ChatKinetica() + + # create chain + ctx_messages = kinetica_llm.load_messages_from_context(self.context_name) + ctx_messages.append(("human", "{input}")) + prompt_template = ChatPromptTemplate.from_messages(ctx_messages) + chain = prompt_template | kinetica_llm + + resp_message = chain.invoke( + {"input": "What are the female users ordered by username?"} + ) + LOG.info(f"SQL Response: {resp_message.content}") + assert isinstance(resp_message, AIMessage) + + @pytest.mark.vcr() + def test_full_chain(self) -> None: + """Generate SQL from a chain and execute the query.""" + kinetica_llm = ChatKinetica() + + # create chain + ctx_messages = kinetica_llm.load_messages_from_context(self.context_name) + ctx_messages.append(("human", "{input}")) + prompt_template = ChatPromptTemplate.from_messages(ctx_messages) + chain = ( + prompt_template + | kinetica_llm + | KineticaSqlOutputParser(kdbc=kinetica_llm.kdbc) + ) + sql_response: KineticaSqlResponse = chain.invoke( + {"input": "What are the female users ordered by username?"} + ) + + assert isinstance(sql_response, KineticaSqlResponse) + LOG.info(f"SQL Response: {sql_response.sql}") + assert isinstance(sql_response.dataframe, pd.DataFrame) + users = sql_response.dataframe["username"] + assert users[0] == "alexander40" + + @classmethod + def _create_fake_records(cls, count: int) -> Generator: + """Generator for fake records.""" + import faker + + faker.Faker.seed(5467) + faker_inst = faker.Faker(locale="en-US") + for id in range(0, count): + rec = dict(id=id, **faker_inst.simple_profile()) + rec["birthdate"] = pd.Timestamp(rec["birthdate"]) + yield rec + + @classmethod + def _create_test_table( + cls, kinetica_dbc: "gpudb.GPUdb", table_name: str, num_records: int + ) -> "gpudb.GPUdbTable": + """Create a table from the fake records generator.""" + import gpudb + + table_df = pd.DataFrame.from_records( + data=cls._create_fake_records(num_records), index="id" + ) + + LOG.info(f"Creating test table '{table_name}' with {num_records} records...") + gpudb_table = gpudb.GPUdbTable.from_df( + table_df, + db=kinetica_dbc, + table_name=table_name, + clear_table=True, + load_data=True, + column_types={}, + ) + return gpudb_table + + @classmethod + def _check_error(cls, response: dict) -> None: + """Convert a DB error into an exception.""" + status = response["status_info"]["status"] + if status != "OK": + message = response["status_info"]["message"] + raise Exception("[%s]: %s" % (status, message)) + + @classmethod + def _create_llm_context( + cls, kinetica_dbc: "gpudb.GPUdb", context_name: str + ) -> None: + """Create an LLM context for the table.""" + + sql = f""" + CREATE OR REPLACE CONTEXT {context_name} + ( + TABLE = {cls.table_name} + COMMENT = 'Contains user profiles.' + ), + ( + SAMPLES = ( + 'How many male users are there?' = + 'select count(1) as num_users + from {cls.table_name} + where sex = ''M'';') + ) + """ + LOG.info(f"Creating context: {context_name}") + response = kinetica_dbc.execute_sql(sql) + cls._check_error(response) diff --git a/libs/community/tests/unit_tests/chat_models/test_imports.py b/libs/community/tests/unit_tests/chat_models/test_imports.py index 58a2901f93..f851a6348d 100644 --- a/libs/community/tests/unit_tests/chat_models/test_imports.py +++ b/libs/community/tests/unit_tests/chat_models/test_imports.py @@ -40,6 +40,7 @@ EXPECTED_ALL = [ "GPTRouter", "ChatYuan2", "ChatZhipuAI", + "ChatKinetica", ] diff --git a/libs/community/tests/unit_tests/chat_models/test_kinetica.py b/libs/community/tests/unit_tests/chat_models/test_kinetica.py new file mode 100644 index 0000000000..8dd6239739 --- /dev/null +++ b/libs/community/tests/unit_tests/chat_models/test_kinetica.py @@ -0,0 +1,67 @@ +"""Test `Kinetica` chat models""" + + +import logging +from typing import Any + +from langchain_core.messages import AIMessage + +from langchain_community.chat_models.kinetica import ChatKinetica, KineticaUtil + +LOG = logging.getLogger(__name__) + + +class TestChatKinetica: + test_ctx_json = """ + { + "payload":{ + "context":[ + { + "table":"demo.test_profiles", + "columns":[ + "username VARCHAR (32) NOT NULL", + "name VARCHAR (32) NOT NULL", + "sex VARCHAR (1) NOT NULL", + "address VARCHAR (64) NOT NULL", + "mail VARCHAR (32) NOT NULL", + "birthdate TIMESTAMP NOT NULL" + ], + "description":"Contains user profiles.", + "rules":[ + + ] + }, + { + "samples":{ + "How many male users are there?": + "select count(1) as num_users from demo.test_profiles where sex = ''M'';" + } + } + ] + } + } +""" + + def test_convert_messages(self, monkeypatch: Any) -> None: + """Test convert messages from context.""" + + def patch_kdbc() -> None: + return None + + monkeypatch.setattr(KineticaUtil, "create_kdbc", patch_kdbc) + + def patch_execute_sql(*args: Any, **kwargs: Any) -> dict: + return dict(Prompt=self.test_ctx_json) + + monkeypatch.setattr(ChatKinetica, "_execute_sql", patch_execute_sql) + + kinetica_llm = ChatKinetica() + + test_messages = kinetica_llm.load_messages_from_context("test") + LOG.info(f"test_messages: {test_messages}") + ai_message = test_messages[-1] + assert isinstance(ai_message, AIMessage) + assert ( + ai_message.content + == "select count(1) as num_users from demo.test_profiles where sex = 'M';" + )