diff --git a/.github/workflows/prIntegrationTests.yml b/.github/workflows/prIntegrationTests.yml index 5f9268b0c..92038dabd 100644 --- a/.github/workflows/prIntegrationTests.yml +++ b/.github/workflows/prIntegrationTests.yml @@ -14,7 +14,7 @@ jobs: strategy: matrix: include: - - test-command: mvn -B compile test -Dtest=*IntegrationTests,!M2MPrivateKeyCredentialsIntegrationTests,!M2MAuthIntegrationTests + - test-command: mvn -B compile test -Dtest=*IntegrationTests,!M2MPrivateKeyCredentialsIntegrationTests,!M2MAuthIntegrationTests,!ThriftCloudFetchFakeIntegrationTests fake-service-type: 'SQL_EXEC' - test-command: mvn -B compile test -Dtest=*IntegrationTests,!M2MPrivateKeyCredentialsIntegrationTests,!SqlExecApiHybridResultsIntegrationTests,!DBFSVolumeIntegrationTests,!M2MAuthIntegrationTests,!UCVolumeIntegrationTests,!SqlExecApiIntegrationTests fake-service-type: 'THRIFT_SERVER' diff --git a/.github/workflows/runIntegrationTests.yml b/.github/workflows/runIntegrationTests.yml index 061ed76cf..8aca7481d 100644 --- a/.github/workflows/runIntegrationTests.yml +++ b/.github/workflows/runIntegrationTests.yml @@ -14,7 +14,7 @@ jobs: strategy: matrix: include: - - test-command: mvn -B compile test -Dtest=*IntegrationTests + - test-command: mvn -B compile test -Dtest=*IntegrationTests,!ThriftCloudFetchFakeIntegrationTests token-secret: DATABRICKS_TOKEN fake-service-type: 'SQL_EXEC' - test-command: mvn -B compile test -Dtest=*IntegrationTests,!M2MPrivateKeyCredentialsIntegrationTests,!SqlExecApiHybridResultsIntegrationTests,!DBFSVolumeIntegrationTests,!M2MAuthIntegrationTests,!UCVolumeIntegrationTests,!SqlExecApiIntegrationTests diff --git a/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSet.java b/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSet.java index 73cde1756..8b41cb5df 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSet.java +++ b/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSet.java @@ -6,6 +6,7 @@ import com.databricks.jdbc.api.IDatabricksResultSet; import com.databricks.jdbc.api.IExecutionStatus; import com.databricks.jdbc.api.impl.arrow.ArrowStreamResult; +import com.databricks.jdbc.api.impl.arrow.ChunkProvider; import com.databricks.jdbc.api.impl.converters.ConverterHelper; import com.databricks.jdbc.api.impl.converters.ObjectConverter; import com.databricks.jdbc.api.impl.volume.VolumeOperationResult; @@ -41,6 +42,7 @@ import java.util.Calendar; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.function.Supplier; import org.apache.http.entity.InputStreamEntity; @@ -2008,6 +2010,14 @@ private BigDecimal applyScaleToBigDecimal(BigDecimal bigDecimal, int columnIndex return bigDecimal.setScale(scale, RoundingMode.HALF_UP); } + @VisibleForTesting + public Optional getChunkProvider() { + if (executionResult instanceof ArrowStreamResult) { + return Optional.ofNullable(((ArrowStreamResult) executionResult).getChunkProvider()); + } + return Optional.empty(); + } + @Override public String toString() { return (new ToStringer(DatabricksResultSet.class)) diff --git a/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractArrowResultChunk.java b/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractArrowResultChunk.java index 6b364c676..f06787673 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractArrowResultChunk.java +++ b/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractArrowResultChunk.java @@ -116,6 +116,15 @@ public Long getChunkIndex() { return chunkIndex; } + /** + * Returns the start row offset of this chunk in the overall result set. + * + * @return row offset + */ + public long getStartRowOffset() { + return rowOffset; + } + /** * Checks if the chunk link is invalid or expired. * @@ -147,6 +156,10 @@ public boolean releaseChunk() { return true; } + public ExternalLink getChunkLink() { + return chunkLink; + } + /** * Sets the external link details for this chunk. * diff --git a/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractRemoteChunkProvider.java b/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractRemoteChunkProvider.java index e05ada5eb..5fc9dc150 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractRemoteChunkProvider.java +++ b/src/main/java/com/databricks/jdbc/api/impl/arrow/AbstractRemoteChunkProvider.java @@ -215,6 +215,10 @@ public long getAllowedChunksInMemory() { return allowedChunksInMemory; } + public T getChunkByIndex(long chunkIndex) { + return chunkIndexToChunksMap.get(chunkIndex); + } + /** Subclasses should override this method to perform their specific cleanup. */ protected void doClose() { // Default implementation does nothing diff --git a/src/main/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResult.java b/src/main/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResult.java index c86c27447..f648ef0ea 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResult.java +++ b/src/main/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResult.java @@ -259,6 +259,16 @@ public long getChunkCount() { return chunkProvider.getChunkCount(); } + /** + * Returns the chunk provider for testing purposes. + * + * @return the chunk provider + */ + @VisibleForTesting + public ChunkProvider getChunkProvider() { + return chunkProvider; + } + private void setColumnInfo(TGetResultSetMetadataResp resultManifest) { columnInfos = new ArrayList<>(); if (resultManifest.getSchema() == null) { diff --git a/src/main/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadService.java b/src/main/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadService.java index 7d59ea13c..1c26d99d9 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadService.java +++ b/src/main/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadService.java @@ -214,13 +214,18 @@ private void triggerNextBatchDownload() { return; } + // Calculate row offset for this batch + final long batchStartRowOffset = getChunkStartRowOffset(batchStartIndex); + LOGGER.info("Starting batch download from index {}", batchStartIndex); currentDownloadTask = CompletableFuture.runAsync( () -> { try { Collection links = - session.getDatabricksClient().getResultChunks(statementId, batchStartIndex); + session + .getDatabricksClient() + .getResultChunks(statementId, batchStartIndex, batchStartRowOffset); LOGGER.info( "Retrieved {} links for batch starting at {} for statement id {}", links.size(), @@ -413,6 +418,28 @@ private void prepareNewBatchDownload(long startIndex) { isDownloadChainStarted.set(false); } + /** + * Gets the start row offset for a given chunk index. + * + * @param chunkIndex the chunk index to get the row offset for + * @return the start row offset for the chunk + */ + private long getChunkStartRowOffset(long chunkIndex) { + T chunk = chunkIndexToChunksMap.get(chunkIndex); + if (chunk == null) { + // Should never happen. + throw new IllegalStateException( + "Chunk not found in map for index " + + chunkIndex + + ". " + + "Total chunks: " + + totalChunks + + ", StatementId: " + + statementId); + } + return chunk.getStartRowOffset(); + } + private boolean isChunkLinkExpired(ExternalLink link) { if (link == null || link.getExpiration() == null) { LOGGER.warn("Link or expiration is null, assuming link is expired"); diff --git a/src/main/java/com/databricks/jdbc/common/util/DatabricksThriftUtil.java b/src/main/java/com/databricks/jdbc/common/util/DatabricksThriftUtil.java index b5df82129..8ad659cd9 100644 --- a/src/main/java/com/databricks/jdbc/common/util/DatabricksThriftUtil.java +++ b/src/main/java/com/databricks/jdbc/common/util/DatabricksThriftUtil.java @@ -73,6 +73,9 @@ public static ExternalLink createExternalLink(TSparkArrowResultLink chunkInfo, l return new ExternalLink() .setExternalLink(chunkInfo.getFileLink()) .setChunkIndex(chunkIndex) + .setRowCount(chunkInfo.getRowCount()) + .setRowOffset(chunkInfo.getStartRowOffset()) + .setByteCount(chunkInfo.getBytesNum()) .setExpiration(Long.toString(chunkInfo.getExpiryTime())); } @@ -90,7 +93,6 @@ public static void verifySuccessStatus(TStatus status, String errorContext, Stri "Error thrift response received [%s] for statementId [%s]", errorContext, statementId) : String.format("Error thrift response received [%s]", errorContext); - LOGGER.error(errorMessage); throw new DatabricksHttpException(errorMessage, status.getSqlState()); } } diff --git a/src/main/java/com/databricks/jdbc/dbclient/IDatabricksClient.java b/src/main/java/com/databricks/jdbc/dbclient/IDatabricksClient.java index e1c6398f1..7dd37d16b 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/IDatabricksClient.java +++ b/src/main/java/com/databricks/jdbc/dbclient/IDatabricksClient.java @@ -119,8 +119,10 @@ DatabricksResultSet getStatementResult( * * @param statementId statement-Id for which chunk should be fetched * @param chunkIndex chunkIndex for which chunk should be fetched + * @param chunkStartRowOffset the row offset where the chunk starts in the result set */ - Collection getResultChunks(StatementId statementId, long chunkIndex) + Collection getResultChunks( + StatementId statementId, long chunkIndex, long chunkStartRowOffset) throws DatabricksSQLException; /** diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClient.java b/src/main/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClient.java index b8dfed049..040446678 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClient.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClient.java @@ -409,7 +409,8 @@ public void cancelStatement(StatementId typedStatementId) throws DatabricksSQLEx } @Override - public Collection getResultChunks(StatementId typedStatementId, long chunkIndex) + public Collection getResultChunks( + StatementId typedStatementId, long chunkIndex, long chunkStartRowOffset) throws DatabricksSQLException { DatabricksThreadContextHolder.setStatementId(typedStatementId); String statementId = typedStatementId.toSQLExecStatementId(); diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessor.java b/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessor.java index 009ace07e..7e18a7a3f 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessor.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessor.java @@ -128,14 +128,32 @@ TBase getThriftResponse(TBase request) throws DatabricksSQLException { } } - TFetchResultsResp getResultSetResp(TOperationHandle operationHandle, String context) + /** + * Fetch the next set of results for the given operation handle with default settings. + * + * @param operationHandle the operation handle + * @return TFetchResultsResp containing the results + * @throws DatabricksHttpException if fetch fails + */ + TFetchResultsResp getResultSetResp(TOperationHandle operationHandle) + throws DatabricksHttpException { + TFetchResultsReq req = createFetchResultsReqWithDefaults(operationHandle); + return executeFetchRequest(req); + } + + /** + * Fetches results starting from a specific row offset. + * + * @param operationHandle the operation handle + * @param startRowOffset the row offset to start fetching from + * @return TFetchResultsResp containing the results + * @throws DatabricksHttpException if fetch fails + */ + TFetchResultsResp getResultSetResp(TOperationHandle operationHandle, long startRowOffset) throws DatabricksHttpException { - return getResultSetResp( - new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS), - operationHandle, - context, - maxRowsPerBlock, - false); + TFetchResultsReq req = createFetchResultsReqWithDefaults(operationHandle); + req.setStartRowOffset(startRowOffset); + return executeFetchRequest(req); } TCancelOperationResp cancelOperation(TCancelOperationReq req) throws DatabricksHttpException { @@ -166,16 +184,10 @@ TCloseOperationResp closeOperation(TCloseOperationReq req) throws DatabricksHttp TFetchResultsResp getMoreResults(IDatabricksStatementInternal parentStatement) throws DatabricksSQLException { - String context = - String.format( - "Fetching more results as it has more rows %s", - parentStatement.getStatementId().toSQLExecStatementId()); - return getResultSetResp( - new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS), - getOperationHandle(parentStatement.getStatementId()), - context, - maxRowsPerBlock, - true); + TFetchResultsReq req = + createFetchResultsReqWithDefaults(getOperationHandle(parentStatement.getStatementId())); + setFetchMetadata(req); + return executeFetchRequest(req); } DatabricksResultSet execute( @@ -227,15 +239,16 @@ DatabricksResultSet execute( resultSet = response.getDirectResults().getResultSet(); resultSet.setResultSetMetadata(response.getDirectResults().getResultSetMetadata()); } else { + verifySuccessStatus( + response.getStatus(), "executeStatement", statementId.toSQLExecStatementId()); + // Fetch the result data after polling + TFetchResultsReq resultsReq = + createFetchResultsReqWithDefaults(response.getOperationHandle()); + setFetchMetadata(resultsReq); long fetchStartTime = System.nanoTime(); - resultSet = - getResultSetResp( - response.getStatus(), - response.getOperationHandle(), - "executeStatement", - maxRowsPerBlock, - true); + resultSet = executeFetchRequest(resultsReq); + long fetchEndTime = System.nanoTime(); long fetchLatencyNanos = fetchEndTime - fetchStartTime; long fetchLatencyMillis = fetchLatencyNanos / 1_000_000; @@ -391,9 +404,16 @@ DatabricksResultSet getStatementResult( response = getOperationStatus(request, statementId); TOperationState operationState = response.getOperationState(); if (operationState == TOperationState.FINISHED_STATE) { + verifySuccessStatus( + response.getStatus(), "getStatementResult", statementId.toSQLExecStatementId()); + long fetchStartTime = System.nanoTime(); - resultSet = - getResultSetResp(response.getStatus(), operationHandle, "getStatementResult", -1, true); + + TFetchResultsReq resultsReq = createFetchResultsReqWithDefaults(operationHandle); + resultsReq.setMaxRows(-1); + setFetchMetadata(resultsReq); + resultSet = executeFetchRequest(resultsReq); + long fetchEndTime = System.nanoTime(); long fetchLatencyNanos = fetchEndTime - fetchStartTime; long fetchLatencyMillis = fetchLatencyNanos / 1_000_000; @@ -481,46 +501,46 @@ void updateConfig(DatabricksConfig newConfig) { this.databricksConfig = newConfig; } - TFetchResultsResp getResultSetResp( - TStatus responseStatus, - TOperationHandle operationHandle, - String context, - int maxRowsPerBlock, - boolean fetchMetadata) + private TFetchResultsResp executeFetchRequest(TFetchResultsReq request) throws DatabricksHttpException { - String statementId = StatementId.loggableStatementId(operationHandle); - verifySuccessStatus(responseStatus, context, statementId); - TFetchResultsReq request = - new TFetchResultsReq() - .setOperationHandle(operationHandle) - .setFetchType((short) 0) // 0 represents Query output. 1 represents Log - .setMaxRows( - maxRowsPerBlock) // Max number of rows that should be returned in the rowset. - .setMaxBytes(DEFAULT_BYTE_LIMIT); - if (fetchMetadata - && ProtocolFeatureUtil.supportsResultSetMetadataFromFetch(serverProtocolVersion)) { - request.setIncludeResultSetMetadata(true); // fetch metadata if supported - } TFetchResultsResp response; try { response = getThriftClient().FetchResults(request); } catch (TException e) { String errorMessage = String.format( - "Error while fetching results from Thrift server. Request maxRows=%d, maxBytes=%d, Error {%s}", + "Error while fetching results from Thrift server. Request maxRows=%d, " + + "maxBytes=%d, Error {%s}", request.getMaxRows(), request.getMaxBytes(), e.getMessage()); - LOGGER.error(e, errorMessage); throw new DatabricksHttpException(errorMessage, e, DatabricksDriverErrorCode.INVALID_STATE); } + + String statementId = StatementId.loggableStatementId(request.getOperationHandle()); verifySuccessStatus( response.getStatus(), String.format( - "Error while fetching results Request maxRows=%d, maxBytes=%d. Response hasMoreRows=%s", + "Error while fetching results Request maxRows=%d, maxBytes=%d. " + + "Response hasMoreRows=%s", request.getMaxRows(), request.getMaxBytes(), response.hasMoreRows), statementId); + return response; } + private TFetchResultsReq createFetchResultsReqWithDefaults(TOperationHandle operationHandle) { + return new TFetchResultsReq() + .setOperationHandle(operationHandle) + .setFetchType((short) 0) // 0 represents Query output. 1 represents Log + .setMaxRows(maxRowsPerBlock) // Max number of rows that should be returned in the rowset. + .setMaxBytes(DEFAULT_BYTE_LIMIT); + } + + private void setFetchMetadata(TFetchResultsReq request) { + if (ProtocolFeatureUtil.supportsResultSetMetadataFromFetch(serverProtocolVersion)) { + request.setIncludeResultSetMetadata(true); + } + } + private TFetchResultsResp listFunctions(TGetFunctionsReq request) throws TException, DatabricksSQLException { if (enableDirectResults) request.setGetDirectResults(DEFAULT_DIRECT_RESULTS); @@ -663,8 +683,11 @@ TFetchResultsResp fetchMetadataResults(TResp response, String contextDescription // Fetch the result data after polling FResp statusField = response.fieldForId(statusFieldId); TStatus status = (TStatus) response.getFieldValue(statusField); - return getResultSetResp( - status, operationHandle, contextDescription, DEFAULT_ROW_LIMIT_PER_BLOCK, false); + verifySuccessStatus(status, contextDescription, statementId); + + TFetchResultsReq resultsReq = createFetchResultsReqWithDefaults(operationHandle); + resultsReq.setMaxRows(DEFAULT_ROW_LIMIT_PER_BLOCK); + return executeFetchRequest(resultsReq); } } diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClient.java b/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClient.java index 4cea9523a..3f9f4b6f5 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClient.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClient.java @@ -37,7 +37,7 @@ import java.math.BigDecimal; import java.sql.SQLException; import java.util.*; -import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; import java.util.stream.Collectors; public class DatabricksThriftServiceClient implements IDatabricksClient, IDatabricksMetadataClient { @@ -301,31 +301,53 @@ public DatabricksResultSet getStatementResult( } @Override - public Collection getResultChunks(StatementId statementId, long chunkIndex) + public Collection getResultChunks( + StatementId statementId, long chunkIndex, long chunkStartRowOffset) throws DatabricksSQLException { String context = String.format( - "public Optional getResultChunk(String statementId = {%s}, long chunkIndex = {%s}) using Thrift client", - statementId, chunkIndex); + "public Collection getResultChunk(String statementId = {%s}, " + + "long chunkIndex = {%s}, long chunkStartRowOffset = {%d}) using Thrift client", + statementId, chunkIndex, chunkStartRowOffset); LOGGER.debug(context); DatabricksThreadContextHolder.setStatementId(statementId); + TFetchResultsResp fetchResultsResp; List externalLinks = new ArrayList<>(); - AtomicInteger index = new AtomicInteger(0); - do { - fetchResultsResp = thriftAccessor.getResultSetResp(getOperationHandle(statementId), context); - fetchResultsResp - .getResults() - .getResultLinks() - .forEach( - resultLink -> - externalLinks.add(createExternalLink(resultLink, index.getAndIncrement()))); - } while (fetchResultsResp.hasMoreRows); - if (chunkIndex < 0 || externalLinks.size() <= chunkIndex) { - String error = String.format("Out of bounds error for chunkIndex. Context: %s", context); - LOGGER.error(error); + AtomicLong index = new AtomicLong(chunkIndex); + + // First fetch uses chunkStartRowOffset. + fetchResultsResp = + thriftAccessor.getResultSetResp(getOperationHandle(statementId), chunkStartRowOffset); + fetchResultsResp + .getResults() + .getResultLinks() + .forEach( + resultLink -> + externalLinks.add(createExternalLink(resultLink, index.getAndIncrement()))); + + if (externalLinks.isEmpty()) { + String error = + "Fetch links returned empty for chunkIndex=" + + chunkIndex + + " startRowOffset=" + + chunkStartRowOffset + + " context=" + + context; throw new DatabricksSQLException(error, DatabricksDriverErrorCode.INVALID_STATE); } + + if (externalLinks.get(0).getRowOffset() != chunkStartRowOffset) { + String error = + "Chunk start row offset mismatch expected=" + + chunkStartRowOffset + + " actual=" + + externalLinks.get(0).getRowOffset() + + " context=" + + context; + throw new DatabricksSQLException(error, DatabricksDriverErrorCode.INVALID_STATE); + } + return externalLinks; } diff --git a/src/test/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResultTest.java b/src/test/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResultTest.java index 7bd55237c..058ed4f47 100644 --- a/src/test/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResultTest.java +++ b/src/test/java/com/databricks/jdbc/api/impl/arrow/ArrowStreamResultTest.java @@ -109,7 +109,7 @@ public void testIteration() throws Exception { .setChunks(this.chunkInfos) .setSchema(new ResultSchema().setColumns(new ArrayList<>()).setColumnCount(0L)); - ResultData resultData = new ResultData().setExternalLinks(getChunkLinks(0L, false)); + ResultData resultData = new ResultData().setExternalLinks(getChunkLinks(0L, 0L, false)); IDatabricksConnectionContext connectionContext = DatabricksConnectionContextFactory.create(JDBC_URL, new Properties()); @@ -189,7 +189,7 @@ public void testGetObject() throws Exception { new ColumnInfo().setTypeName(ColumnInfoTypeName.DOUBLE))) .setColumnCount(2L)); - ResultData resultData = new ResultData().setExternalLinks(getChunkLinks(0L, false)); + ResultData resultData = new ResultData().setExternalLinks(getChunkLinks(0L, 0L, false)); IDatabricksConnectionContext connectionContext = DatabricksConnectionContextFactory.create(JDBC_URL, new Properties()); @@ -242,11 +242,12 @@ public void testGeospatialTypeHandling() { assertFalse(ArrowStreamResult.isGeospatialType(ColumnInfoTypeName.TIMESTAMP)); } - private List getChunkLinks(long chunkIndex, boolean isLast) { + private List getChunkLinks(long chunkIndex, long chunkRowOffset, boolean isLast) { List chunkLinks = new ArrayList<>(); ExternalLink chunkLink = new ExternalLink() .setChunkIndex(chunkIndex) + .setRowOffset(chunkRowOffset) .setExternalLink(CHUNK_URL_PREFIX + chunkIndex) .setExpiration(Instant.now().plusSeconds(3600L).toString()); if (!isLast) { @@ -283,8 +284,9 @@ private void setupMockResponse() throws Exception { private void setupResultChunkMocks() throws DatabricksSQLException { for (int chunkIndex = 1; chunkIndex < numberOfChunks; chunkIndex++) { boolean isLastChunk = (chunkIndex == (numberOfChunks - 1)); - when(mockedSdkClient.getResultChunks(STATEMENT_ID, chunkIndex)) - .thenReturn(getChunkLinks(chunkIndex, isLastChunk)); + long chunkRowOffset = chunkInfos.get(chunkIndex).getRowOffset(); + when(mockedSdkClient.getResultChunks(STATEMENT_ID, chunkIndex, chunkRowOffset)) + .thenReturn(getChunkLinks(chunkIndex, chunkRowOffset, isLastChunk)); } } diff --git a/src/test/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadServiceTest.java b/src/test/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadServiceTest.java index 52981ced0..e505c69e1 100644 --- a/src/test/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadServiceTest.java +++ b/src/test/java/com/databricks/jdbc/api/impl/arrow/ChunkLinkDownloadServiceTest.java @@ -55,14 +55,8 @@ void testGetLinkForChunk_Success() when(mockSession.getDatabricksClient()).thenReturn(mockClient); // Mock the response to link requests - when(mockClient.getResultChunks(eq(mockStatementId), eq(1L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(1L), anyLong())) .thenReturn(Collections.singletonList(linkForChunkIndex_1)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(2L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_2)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(3L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_3)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(4L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_4)); long chunkIndex = 1L; when(mockChunkMap.get(chunkIndex)).thenReturn(mock(ArrowResultChunk.class)); @@ -78,7 +72,7 @@ void testGetLinkForChunk_Success() TimeUnit.MILLISECONDS.sleep(500); assertEquals(linkForChunkIndex_1, result); - verify(mockClient).getResultChunks(mockStatementId, NEXT_BATCH_START_INDEX); + verify(mockClient).getResultChunks(mockStatementId, NEXT_BATCH_START_INDEX, 0); } @Test @@ -115,7 +109,8 @@ void testGetLinkForChunk_ClientError() new DatabricksSQLException("Test error", DatabricksDriverErrorCode.INVALID_STATE); when(mockSession.getDatabricksClient()).thenReturn(mockClient); // Mock an error in response to the link request - when(mockClient.getResultChunks(eq(mockStatementId), anyLong())).thenThrow(expectedError); + when(mockClient.getResultChunks(eq(mockStatementId), anyLong(), anyLong())) + .thenThrow(expectedError); when(mockChunkMap.get(chunkIndex)).thenReturn(mock(ArrowResultChunk.class)); ChunkLinkDownloadService service = @@ -133,24 +128,22 @@ void testGetLinkForChunk_ClientError() void testAutoTriggerForSEAClient() throws DatabricksSQLException, InterruptedException { when(mockSession.getDatabricksClient()).thenReturn(mockClient); // Mock the response to link requests - when(mockClient.getResultChunks(eq(mockStatementId), eq(1L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(1L), anyLong())) .thenReturn(Collections.singletonList(linkForChunkIndex_1)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(2L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_2)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(3L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_3)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(4L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_4)); + // Download chain will be triggered immediately in the constructor when(mockSession.getConnectionContext().getClientType()).thenReturn(DatabricksClientType.SEA); + long chunkIndex = 1L; + when(mockChunkMap.get(chunkIndex)).thenReturn(mock(ArrowResultChunk.class)); + new ChunkLinkDownloadService<>( mockSession, mockStatementId, TOTAL_CHUNKS, mockChunkMap, NEXT_BATCH_START_INDEX); // Sleep to allow the service to complete the download pipeline TimeUnit.MILLISECONDS.sleep(500); - verify(mockClient).getResultChunks(mockStatementId, NEXT_BATCH_START_INDEX); + verify(mockClient).getResultChunks(mockStatementId, NEXT_BATCH_START_INDEX, 0); } @Test @@ -163,14 +156,8 @@ void testHandleExpiredLinks() when(mockSession.getDatabricksClient()).thenReturn(mockClient); // Mock the response to link requests. Return the expired link for chunk index 1 - when(mockClient.getResultChunks(eq(mockStatementId), eq(1L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(1L), anyLong())) .thenReturn(Collections.singletonList(expiredLinkForChunkIndex_1)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(2L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_2)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(3L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_3)); - when(mockClient.getResultChunks(eq(mockStatementId), eq(4L))) - .thenReturn(Collections.singletonList(linkForChunkIndex_4)); long chunkIndex = 1L; ArrowResultChunk mockChunk = mock(ArrowResultChunk.class); @@ -185,7 +172,7 @@ void testHandleExpiredLinks() TimeUnit.MILLISECONDS.sleep(500); // Mock a new valid link for chunk index 1 - when(mockClient.getResultChunks(eq(mockStatementId), eq(1L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(1L), anyLong())) .thenReturn(Collections.singletonList(linkForChunkIndex_1)); // Try to get the link for chunk index 1. Download chain will be re-triggered because the link // is expired @@ -195,7 +182,7 @@ void testHandleExpiredLinks() TimeUnit.MILLISECONDS.sleep(500); assertEquals(linkForChunkIndex_1, result); - verify(mockClient, times(2)).getResultChunks(mockStatementId, chunkIndex); + verify(mockClient, times(2)).getResultChunks(mockStatementId, chunkIndex, 0); } @Test @@ -222,13 +209,13 @@ void testBatchDownloadChaining() when(mockSession.getDatabricksClient()).thenReturn(mockClient); // Mock the links for the first batch. The link futures for both chunks will be completed at the // same time - when(mockClient.getResultChunks(eq(mockStatementId), eq(1L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(1L), anyLong())) .thenReturn(Arrays.asList(linkForChunkIndex_1, linkForChunkIndex_2)); // Mock the links for the second batch. - when(mockClient.getResultChunks(eq(mockStatementId), eq(3L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(3L), anyLong())) .thenReturn(Arrays.asList(linkForChunkIndex_3, linkForChunkIndex_4)); // Mock the links for the third batch. - when(mockClient.getResultChunks(eq(mockStatementId), eq(5L))) + when(mockClient.getResultChunks(eq(mockStatementId), eq(5L), anyLong())) .thenReturn(Arrays.asList(linkForChunkIndex_5, linkForChunkIndex_6)); ChunkLinkDownloadService service = @@ -260,11 +247,11 @@ void testBatchDownloadChaining() assertEquals(linkForChunkIndex_5, result5); assertEquals(linkForChunkIndex_6, result6); // Verify the request for first batch - verify(mockClient, times(1)).getResultChunks(mockStatementId, 1L); + verify(mockClient, times(1)).getResultChunks(mockStatementId, 1L, 0); // Verify the request for second batch - verify(mockClient, times(1)).getResultChunks(mockStatementId, 3L); + verify(mockClient, times(1)).getResultChunks(mockStatementId, 3L, 0); // Verify the request for third batch - verify(mockClient, times(1)).getResultChunks(mockStatementId, 5L); + verify(mockClient, times(1)).getResultChunks(mockStatementId, 5L, 0); } private ExternalLink createExternalLink( diff --git a/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessorTest.java b/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessorTest.java index 56fe6d4a0..0721704af 100644 --- a/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessorTest.java +++ b/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessorTest.java @@ -387,33 +387,29 @@ void testCloseOperation_error() @Test void testIncludeResultSetMetadataNotSetForOldProtocol() - throws TException, - DatabricksHttpException, - DatabricksParsingException, - DatabricksValidationException { + throws TException, DatabricksSQLException { + TOperationHandle operationHandle = + new TOperationHandle() + .setOperationId(handleIdentifier) + .setHasResultSet(false) + .setOperationType(TOperationType.UNKNOWN); DatabricksThriftAccessor accessor = spy(new DatabricksThriftAccessor(connectionContext)); doReturn(thriftClient).when(accessor).getThriftClient(); accessor.setServerProtocolVersion(TProtocolVersion.SPARK_CLI_SERVICE_PROTOCOL_V4); TFetchResultsReq expectedReq = getFetchResultsRequest(false); + expectedReq.setOperationHandle(operationHandle); + when(thriftClient.FetchResults(expectedReq)) .thenReturn(fetchResultsResponse); // request has no includeResultSetMetadata - accessor.getResultSetResp( - new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS), - tOperationHandle, - "context", - connectionContext.getRowsFetchedPerBlock(), - true); + when(parentStatement.getStatementId()).thenReturn(StatementId.deserialize(TEST_STMT_ID)); + accessor.getMoreResults(parentStatement); accessor.setServerProtocolVersion(TProtocolVersion.SPARK_CLI_SERVICE_PROTOCOL_V9); expectedReq = getFetchResultsRequest(true); + expectedReq.setOperationHandle(operationHandle); when(thriftClient.FetchResults(expectedReq)) .thenReturn(fetchResultsResponse); // request has includeResultSetMetadata - accessor.getResultSetResp( - new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS), - tOperationHandle, - "context", - connectionContext.getRowsFetchedPerBlock(), - true); + accessor.getMoreResults(parentStatement); } @Test diff --git a/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClientTest.java b/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClientTest.java index 27f4c04e5..7b527fd7e 100644 --- a/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClientTest.java +++ b/src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftServiceClientTest.java @@ -10,6 +10,7 @@ import static com.databricks.jdbc.model.core.ColumnInfoTypeName.*; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -369,11 +370,11 @@ void testGetResultChunks() throws SQLException { .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS)) .setResults(resultData) .setResultSetMetadata(resultMetadataData); - when(thriftAccessor.getResultSetResp(any(), any())).thenReturn(response); + when(thriftAccessor.getResultSetResp(any(), anyLong())).thenReturn(response); when(resultData.getResultLinks()) .thenReturn( Collections.singletonList(new TSparkArrowResultLink().setFileLink(TEST_STRING))); - Collection resultChunks = client.getResultChunks(TEST_STMT_ID, 0); + Collection resultChunks = client.getResultChunks(TEST_STMT_ID, 0, 0); assertEquals(resultChunks.size(), 1); assertEquals(resultChunks.stream().findFirst().get().getExternalLink(), TEST_STRING); } @@ -387,10 +388,54 @@ void testGetResultChunksThrowsError() throws SQLException { .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS)) .setResults(resultData) .setResultSetMetadata(resultMetadataData); - when(thriftAccessor.getResultSetResp(any(), any())).thenReturn(response); - assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, -1)); - assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, 2)); - assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, 1)); + when(thriftAccessor.getResultSetResp(any(), anyLong())).thenReturn(response); + assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, -1, 0)); + assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, 2, 0)); + assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, 1, 0)); + } + + @Test + void testGetResultChunksEmptyLinksThrowsException() throws SQLException { + DatabricksThriftServiceClient client = + new DatabricksThriftServiceClient(thriftAccessor, connectionContext); + TFetchResultsResp response = + new TFetchResultsResp() + .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS)) + .setResults(resultData) + .setResultSetMetadata(resultMetadataData); + when(thriftAccessor.getResultSetResp(any(), eq(0L))).thenReturn(response); + when(resultData.getResultLinks()).thenReturn(Collections.emptyList()); + + assertThrows(DatabricksSQLException.class, () -> client.getResultChunks(TEST_STMT_ID, 0, 0)); + } + + @Test + void testGetResultChunksRowOffsetMismatchThrowsException() throws SQLException { + DatabricksThriftServiceClient client = + new DatabricksThriftServiceClient(thriftAccessor, connectionContext); + + long requestedStartRowOffset = 1000L; + long actualStartRowOffset = 500L; + + TSparkArrowResultLink resultLink = + new TSparkArrowResultLink() + .setFileLink(TEST_STRING) + .setStartRowOffset(actualStartRowOffset) + .setRowCount(100) + .setBytesNum(1024) + .setExpiryTime(System.currentTimeMillis() + 3600000); + + TFetchResultsResp response = + new TFetchResultsResp() + .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS)) + .setResults(resultData) + .setResultSetMetadata(resultMetadataData); + when(thriftAccessor.getResultSetResp(any(), eq(requestedStartRowOffset))).thenReturn(response); + when(resultData.getResultLinks()).thenReturn(Collections.singletonList(resultLink)); + + assertThrows( + DatabricksSQLException.class, + () -> client.getResultChunks(TEST_STMT_ID, 5, requestedStartRowOffset)); } @Test diff --git a/src/test/java/com/databricks/jdbc/integration/e2e/ThriftCloudFetchTests.java b/src/test/java/com/databricks/jdbc/integration/e2e/ThriftCloudFetchTests.java new file mode 100644 index 000000000..77914208e --- /dev/null +++ b/src/test/java/com/databricks/jdbc/integration/e2e/ThriftCloudFetchTests.java @@ -0,0 +1,187 @@ +package com.databricks.jdbc.integration.e2e; + +import static com.databricks.jdbc.integration.IntegrationTestUtil.getValidJDBCConnection; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.databricks.jdbc.api.impl.DatabricksConnection; +import com.databricks.jdbc.api.impl.DatabricksResultSet; +import com.databricks.jdbc.api.impl.DatabricksStatement; +import com.databricks.jdbc.api.impl.arrow.AbstractRemoteChunkProvider; +import com.databricks.jdbc.api.impl.arrow.ArrowResultChunk; +import com.databricks.jdbc.api.impl.arrow.ChunkProvider; +import com.databricks.jdbc.api.internal.IDatabricksSession; +import com.databricks.jdbc.dbclient.IDatabricksClient; +import com.databricks.jdbc.dbclient.impl.common.StatementId; +import com.databricks.jdbc.exception.DatabricksSQLException; +import com.databricks.jdbc.log.JdbcLogger; +import com.databricks.jdbc.log.JdbcLoggerFactory; +import com.databricks.jdbc.model.core.ExternalLink; +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.Properties; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** Integration test to test CloudFetch link refetching using Thrift client. */ +public class ThriftCloudFetchTests { + /** Connection to the Databricks cluster. */ + private Connection connection; + + /** Table with lot of rows to generate multiple CloudFetch chunks. */ + private static final String TABLE = "samples.tpch.lineitem"; + + private static final JdbcLogger LOGGER = JdbcLoggerFactory.getLogger(ThriftCloudFetchTests.class); + + @BeforeEach + void setUp() throws Exception { + Properties props = new Properties(); + props.put("UseThriftClient", "1"); // Create connection with Thrift client enabled + props.put("EnableDirectResults", "0"); // Disable direct results to test CloudFetch + props.put("CloudFetchThreadPoolSize", "1"); // Download only a small chunk. + + connection = getValidJDBCConnection(props); + } + + @AfterEach + void tearDown() throws Exception { + if (connection != null && !connection.isClosed()) { + connection.close(); + } + } + + /** + * Test refetching CloudFetch links from various startRowOffsets. + * + *

This test: + * + *

    + *
  1. Executes a query that generates multiple CloudFetch chunks + *
  2. Extracts the chunk provider to get chunk metadata + *
  3. Refetches from 3 different offsets: start (0), middle, and end + *
  4. Verifies each refetch returns correct subset of links + *
  5. Verifies link properties match (chunkIndex, rowOffset, rowCount, byteCount) + *
+ */ + @Test + void testCloudFetchLinksRefetchAtStartRowOffset() throws Exception { + // Step 1: Execute a query that returns a large dataset with multiple CloudFetch chunks + int maxRows = 6_000_000; // Generate many chunk links. + String query = "SELECT * FROM " + TABLE + " LIMIT " + maxRows; + + try (Statement stmt = connection.createStatement()) { + stmt.execute(query); + ResultSet rs = stmt.getResultSet(); + + LOGGER.info("Query executed, extracting chunks..."); + + // Step 2: Extract the chunks that were created by initializeChunksMap + DatabricksStatement dbStatement = (DatabricksStatement) stmt; + StatementId statementId = dbStatement.getStatementId(); + assertNotNull(statementId, "StatementId should be set after execution"); + + Optional chunkProviderOptional = ((DatabricksResultSet) rs).getChunkProvider(); + assertTrue( + chunkProviderOptional.isPresent(), + "Chunk provider should exist for CloudFetch result set"); + @SuppressWarnings("unchecked") + AbstractRemoteChunkProvider chunkProvider = + (AbstractRemoteChunkProvider) chunkProviderOptional.get(); + + long totalChunks = chunkProvider.getChunkCount(); + + assertTrue( + totalChunks > 2, "Should have at least 3 chunks for this test, got: " + totalChunks); + LOGGER.info("Total chunks: " + totalChunks); + + // Step 3: Test refetching from various chunk indices. + DatabricksConnection dbConnection = + (DatabricksConnection) connection.unwrap(DatabricksConnection.class); + IDatabricksSession session = dbConnection.getSession(); + IDatabricksClient client = session.getDatabricksClient(); + + long end = totalChunks - 1; + long mid = totalChunks / 2; + List chunkIndicesToTest = new ArrayList<>(List.of(0L, 1L, mid - 1, mid, mid + 1, end)); + // Randomize the order to make sure there is no sequence to the responses. We use FETCH_NEXT + // when fetching the next set of links. + Collections.shuffle(chunkIndicesToTest); + + for (long chunkIndex : chunkIndicesToTest) { + ArrowResultChunk targetChunk = chunkProvider.getChunkByIndex(chunkIndex); + assertNotNull(targetChunk, "Target chunk should exist at index " + chunkIndex); + + long chunkStartRowOffset = targetChunk.getStartRowOffset(); + LOGGER.info( + "Refetching from chunk index " + + chunkIndex + + " with startRowOffset: " + + chunkStartRowOffset); + + testRefetchLinks(statementId, chunkIndex, chunkStartRowOffset, chunkProvider, client); + } + } + } + + private void testRefetchLinks( + StatementId statementId, + long chunkIndex, + long chunkStartRowOffset, + AbstractRemoteChunkProvider chunkProvider, + IDatabricksClient client) + throws DatabricksSQLException { + // Fetch from the startRowOffset of the target chunk. + Collection refetchedLinks = + client.getResultChunks(statementId, chunkIndex, chunkStartRowOffset); + + assertNotNull(refetchedLinks, "Refetched links should not be null"); + assertFalse(refetchedLinks.isEmpty(), "Refetched links should not be empty"); + + LOGGER.info("Refetched " + refetchedLinks.size() + " links from chunk index " + chunkIndex); + + // Convert refetched links to a list for comparison + List refetchedLinksList = new ArrayList<>(refetchedLinks); + + // Compare each refetched link with the corresponding original link. + for (int i = 0; i < refetchedLinksList.size(); i++) { + long originalChunkIndex = chunkIndex + i; + ArrowResultChunk originalChunk = chunkProvider.getChunkByIndex(originalChunkIndex); + assertNotNull(originalChunk, "Original chunk should exist at index " + originalChunkIndex); + + ExternalLink originalLink = originalChunk.getChunkLink(); + ExternalLink refetchedLink = refetchedLinksList.get(i); + + assertEquals( + originalLink.getChunkIndex(), + refetchedLink.getChunkIndex(), + "Chunk index should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getRowOffset(), + refetchedLink.getRowOffset(), + "Start row offset should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getRowCount(), + refetchedLink.getRowCount(), + "Row count should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getByteCount(), + refetchedLink.getByteCount(), + "Byte count should match for chunk " + originalChunkIndex); + + assertNotNull(originalLink.getExternalLink(), "Original file link should not be null"); + assertNotNull(refetchedLink.getExternalLink(), "Refetched file link should not be null"); + } + } +} diff --git a/src/test/java/com/databricks/jdbc/integration/fakeservice/tests/ThriftCloudFetchFakeIntegrationTests.java b/src/test/java/com/databricks/jdbc/integration/fakeservice/tests/ThriftCloudFetchFakeIntegrationTests.java new file mode 100644 index 000000000..11487a4e9 --- /dev/null +++ b/src/test/java/com/databricks/jdbc/integration/fakeservice/tests/ThriftCloudFetchFakeIntegrationTests.java @@ -0,0 +1,177 @@ +package com.databricks.jdbc.integration.fakeservice.tests; + +import static com.databricks.jdbc.integration.IntegrationTestUtil.getValidJDBCConnection; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.databricks.jdbc.api.impl.DatabricksConnection; +import com.databricks.jdbc.api.impl.DatabricksResultSet; +import com.databricks.jdbc.api.impl.DatabricksStatement; +import com.databricks.jdbc.api.impl.arrow.AbstractRemoteChunkProvider; +import com.databricks.jdbc.api.impl.arrow.ArrowResultChunk; +import com.databricks.jdbc.api.impl.arrow.ChunkProvider; +import com.databricks.jdbc.api.internal.IDatabricksSession; +import com.databricks.jdbc.dbclient.IDatabricksClient; +import com.databricks.jdbc.dbclient.impl.common.StatementId; +import com.databricks.jdbc.exception.DatabricksSQLException; +import com.databricks.jdbc.integration.fakeservice.AbstractFakeServiceIntegrationTests; +import com.databricks.jdbc.model.core.ExternalLink; +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Optional; +import java.util.Properties; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** Integration test to test CloudFetch link refetching using Thrift client. */ +public class ThriftCloudFetchFakeIntegrationTests extends AbstractFakeServiceIntegrationTests { + /** Connection to the Databricks cluster. */ + private Connection connection; + + /** Table with a lot of rows to generate multiple CloudFetch chunks. */ + private static final String TABLE = "samples.tpch.lineitem"; + + private static final Logger LOGGER = + LogManager.getLogger(ThriftCloudFetchFakeIntegrationTests.class); + + @BeforeEach + void setUp() throws Exception { + Properties props = new Properties(); + props.put("EnableDirectResults", "0"); // Disable direct results to test CloudFetch + props.put("CloudFetchThreadPoolSize", "1"); // Download only a small chunk. + + // Thrift is set up in the command line option. + + LOGGER.info("Setting up connection with properties: {}", props); + connection = getValidJDBCConnection(props); + } + + @AfterEach + void tearDown() throws Exception { + if (connection != null && !connection.isClosed()) { + connection.close(); + } + } + + /** Test refetching CloudFetch links from various startRowOffsets. */ + @Test + void testCloudFetchLinksRefetchAtStartRowOffset() throws Exception { + final int maxRows = 6_000_000; // Generate many chunk links. + final String sql = "SELECT * FROM " + TABLE + " LIMIT " + maxRows; + + LOGGER.info("Executing sql query: " + sql); + try (Statement stmt = connection.createStatement()) { + stmt.setMaxRows(maxRows); + stmt.execute(sql); + ResultSet rs = stmt.getResultSet(); + + LOGGER.info("Query executed, extracting chunks ..."); + + // Extract the chunks that were created by initializeChunksMap + DatabricksStatement dbStatement = (DatabricksStatement) stmt; + StatementId statementId = dbStatement.getStatementId(); + assertNotNull(statementId, "StatementId should be set after execution"); + + Optional chunkProviderOptional = ((DatabricksResultSet) rs).getChunkProvider(); + assertTrue( + chunkProviderOptional.isPresent(), + "Chunk provider should exist for CloudFetch result set"); + @SuppressWarnings("unchecked") + AbstractRemoteChunkProvider chunkProvider = + (AbstractRemoteChunkProvider) chunkProviderOptional.get(); + + long totalChunks = chunkProvider.getChunkCount(); + assertTrue( + totalChunks > 2, "Should have at least 3 chunks for this test, got: " + totalChunks); + LOGGER.info("Received total chunks: {}", totalChunks); + + // Get client for refetching + DatabricksConnection dbConnection = connection.unwrap(DatabricksConnection.class); + IDatabricksSession session = dbConnection.getSession(); + IDatabricksClient client = session.getDatabricksClient(); + + // Test refetching from various chunk indices: start (0), middle, and end. + long middle = totalChunks / 2; + long end = totalChunks - 1; + + // Go through some corner cases. + List chunkIndices = List.of(middle, 0L, middle + 1, end, middle - 1, 1L); + + for (long chunkIndex : chunkIndices) { + ArrowResultChunk targetChunk = chunkProvider.getChunkByIndex(chunkIndex); + assertNotNull(targetChunk, "Target chunk should exist at index " + chunkIndex); + + long chunkStartRowOffset = targetChunk.getStartRowOffset(); + LOGGER.info( + "Refetching from chunk index {} with startRowOffset: {}", + chunkIndex, + chunkStartRowOffset); + + testRefetchLinks(statementId, chunkIndex, chunkStartRowOffset, chunkProvider, client); + } + } + } + + private void testRefetchLinks( + StatementId statementId, + long chunkIndex, + long chunkStartRowOffset, + AbstractRemoteChunkProvider chunkProvider, + IDatabricksClient client) + throws DatabricksSQLException { + + // Fetch from the startRowOffset of the target chunk + Collection refetchedLinks = + client.getResultChunks(statementId, chunkIndex, chunkStartRowOffset); + + assertNotNull(refetchedLinks, "Refetched links should not be null"); + assertFalse(refetchedLinks.isEmpty(), "Refetched links should not be empty"); + + LOGGER.info("Refetched " + refetchedLinks.size() + " links from chunk index " + chunkIndex); + + // Convert to list for comparison + List refetchedLinksList = new ArrayList<>(refetchedLinks); + + // Compare each refetched link with the corresponding original link + for (int i = 0; i < refetchedLinksList.size(); i++) { + long originalChunkIndex = chunkIndex + i; + ArrowResultChunk originalChunk = chunkProvider.getChunkByIndex(originalChunkIndex); + assertNotNull(originalChunk, "Original chunk should exist at index " + originalChunkIndex); + + ExternalLink originalLink = originalChunk.getChunkLink(); + ExternalLink refetchedLink = refetchedLinksList.get(i); + + assertEquals( + originalLink.getChunkIndex(), + refetchedLink.getChunkIndex(), + "Chunk index should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getRowOffset(), + refetchedLink.getRowOffset(), + "Start row offset should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getRowCount(), + refetchedLink.getRowCount(), + "Row count should match for chunk " + originalChunkIndex); + + assertEquals( + originalLink.getByteCount(), + refetchedLink.getByteCount(), + "Byte count should match for chunk " + originalChunkIndex); + + assertNotNull(originalLink.getExternalLink(), "Original file link should not be null"); + assertNotNull(refetchedLink.getExternalLink(), "Refetched file link should not be null"); + } + } +} diff --git a/src/test/resources/__files/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.txt b/src/test/resources/__files/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.txt new file mode 100644 index 000000000..23a7f70d5 Binary files /dev/null and b/src/test/resources/__files/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.txt differ diff --git a/src/test/resources/cloudfetchthriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.json b/src/test/resources/cloudfetchthriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.json new file mode 100644 index 000000000..2d011a463 --- /dev/null +++ b/src/test/resources/cloudfetchthriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.json @@ -0,0 +1,25 @@ +{ + "id" : "a3abfa25-c015-41dc-a336-187bfc7457ee", + "name" : "oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921", + "request" : { + "url" : "/oregon-staging/6051921418418893.jobs/sql/2025-12-04/04/results_2025-12-04T04%3A51%3A00Z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921?[REDACTED]X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20251204T045123Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&[REDACTED]X-Amz-Signature=ae03a2262260f77a2a32464718f82dae7994c7ef61ebf101906236c494e4c391", + "method" : "GET" + }, + "response" : { + "status" : 200, + "bodyFileName" : "oregon-staging_6051921418418893.jobs_sql_2025-12-04_04_results_2025-12-04t045100z_4aa2cc7a-e5f1-48b6-b9d1-0ac44f941921-a3abfa25-c015-41dc-a336-187bfc7457ee.txt", + "headers" : { + "Accept-Ranges" : "bytes", + "Server" : "AmazonS3", + "ETag" : "\"0b67d8f4724a372b1d3d916bb1e59524\"", + "Last-Modified" : "Thu, 04 Dec 2025 04:51:02 GMT", + "x-amz-request-id" : "FPVS8ZP12JSTHJ5E", + "x-amz-server-side-encryption" : "AES256", + "x-amz-id-2" : "BGQzoy78KHOarLxnR3apQohh3GrjRwQxyITS6urFspyd4Ac0dU60jcz60pH0pJAZ9X43G590qr8=", + "Date" : "Thu, 04 Dec 2025 04:51:30 GMT", + "Content-Type" : "binary/octet-stream" + } + }, + "uuid" : "a3abfa25-c015-41dc-a336-187bfc7457ee", + "insertionIndex" : 1 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oidc_.well-known_oauth-authorization-server-9fe698af-5c02-43cf-83e0-88c1407c1ee2.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oidc_.well-known_oauth-authorization-server-9fe698af-5c02-43cf-83e0-88c1407c1ee2.json new file mode 100644 index 000000000..ef36976af --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/oidc_.well-known_oauth-authorization-server-9fe698af-5c02-43cf-83e0-88c1407c1ee2.json @@ -0,0 +1,31 @@ +{ + "id" : "9fe698af-5c02-43cf-83e0-88c1407c1ee2", + "name" : "oidc_.well-known_oauth-authorization-server", + "request" : { + "url" : "/oidc/.well-known/oauth-authorization-server", + "method" : "GET" + }, + "response" : { + "status" : 200, + "body" : "{\"authorization_endpoint\":\"https:\\/\\/e2-dogfood.staging.cloud.databricks.com\\/oidc\\/v1\\/authorize\",\"token_endpoint\":\"https:\\/\\/e2-dogfood.staging.cloud.databricks.com\\/oidc\\/v1\\/token\",\"issuer\":\"https:\\/\\/e2-dogfood.staging.cloud.databricks.com\\/oidc\",\"jwks_uri\":\"https:\\/\\/oregon.staging.cloud.databricks.com\\/oidc\\/jwks.json\",\"scopes_supported\":[\"all-apis\",\"apps.apps\",\"catalog.artifact-allowlists\",\"catalog.catalogs\",\"catalog.connections\",\"catalog.credentials\",\"catalog.entity-tag-assignments\",\"catalog.external-lineage\",\"catalog.external-locations\",\"catalog.external-metadata\",\"catalog.functions\",\"catalog.grants\",\"catalog.metastores\",\"catalog.model-versions\",\"catalog.online-tables\",\"catalog.policies\",\"catalog.quality-monitors\",\"catalog.registered-models\",\"catalog.resource-quotas\",\"catalog.rfa\",\"catalog.schemas\",\"catalog.storage-credentials\",\"catalog.system-schemas\",\"catalog.table-constraints\",\"catalog.tables\",\"catalog.temporary-path-credentials\",\"catalog.temporary-table-credentials\",\"catalog.volumes\",\"catalog.workspace-bindings\",\"cleanrooms.clean-room-asset-revisions\",\"cleanrooms.clean-room-assets\",\"cleanrooms.clean-room-auto-approval-rules\",\"cleanrooms.clean-room-task-runs\",\"cleanrooms.clean-rooms\",\"compute.cluster-policies\",\"compute.clusters\",\"compute.command-execution\",\"compute.global-init-scripts\",\"compute.instance-pools\",\"compute.instance-profiles\",\"compute.libraries\",\"compute.policy-compliance-for-clusters\",\"compute.policy-families\",\"dashboards.genie\",\"dashboards.lakeview\",\"dashboards.lakeview-embedded\",\"database.database\",\"dataquality.data-quality\",\"email\",\"files.dbfs\",\"files.files\",\"iam.account-access-control-proxy\",\"iam.current-user\",\"iam.groups\",\"iam.permissions\",\"iam.service-principals\",\"iam.users\",\"iamv2.iam\",\"jobs.jobs\",\"jobs.policy-compliance-for-jobs\",\"marketplace.consumer-fulfillments\",\"marketplace.consumer-installations\",\"marketplace.consumer-listings\",\"marketplace.consumer-personalization-requests\",\"marketplace.consumer-providers\",\"marketplace.provider-exchange-filters\",\"marketplace.provider-exchanges\",\"marketplace.provider-files\",\"marketplace.provider-listings\",\"marketplace.provider-personalization-requests\",\"marketplace.provider-provider-analytics-dashboards\",\"marketplace.provider-providers\",\"mcp.external\",\"mcp.functions\",\"mcp.genie\",\"mcp.sql\",\"mcp.vectorsearch\",\"ml.experiments\",\"ml.model-registry\",\"oauth2.service-principal-secrets-proxy\",\"offline_access\",\"openid\",\"pipelines.pipelines\",\"profile\",\"qualitymonitorv2.quality-monitor\",\"serving.serving-endpoints\",\"settings.aibi-dashboard-embedding-access-policy\",\"settings.aibi-dashboard-embedding-approved-domains\",\"settings.automatic-cluster-update\",\"settings.compliance-security-profile\",\"settings.dashboard-email-subscriptions\",\"settings.default-namespace\",\"settings.disable-legacy-access\",\"settings.disable-legacy-dbfs\",\"settings.enable-export-notebook\",\"settings.enable-notebook-table-clipboard\",\"settings.enable-results-downloading\",\"settings.enhanced-security-monitoring\",\"settings.ip-access-lists\",\"settings.notification-destinations\",\"settings.restrict-workspace-admins\",\"settings.sql-results-download\",\"settings.token-management\",\"settings.tokens\",\"settings.workspace-conf\",\"settingsv2.settings\",\"sharing.providers\",\"sharing.recipient-activation\",\"sharing.recipient-federation-policies\",\"sharing.recipients\",\"sharing.shares\",\"sql\",\"sql.alerts\",\"sql.alerts-legacy\",\"sql.alerts-v2\",\"sql.dashboards\",\"sql.data-sources\",\"sql.dbsql-permissions\",\"sql.driver\",\"sql.queries\",\"sql.queries-legacy\",\"sql.query-history\",\"sql.statement-execution\",\"sql.warehouses\",\"tags.tag-policies\",\"tags.workspace-entity-tag-assignments\",\"vectorsearch.vector-search-endpoints\",\"vectorsearch.vector-search-indexes\",\"workspace.git-credentials\",\"workspace.repos\",\"workspace.secrets\",\"workspace.workspace\"],\"response_types_supported\":[\"code\",\"id_token\"],\"response_modes_supported\":[\"query\",\"fragment\",\"form_post\"],\"grant_types_supported\":[\"client_credentials\",\"authorization_code\",\"refresh_token\"],\"code_challenge_methods_supported\":[\"S256\"],\"token_endpoint_auth_methods_supported\":[\"client_secret_basic\",\"client_secret_post\",\"none\"],\"subject_types_supported\":[\"public\"],\"id_token_signing_alg_values_supported\":[\"RS256\"],\"claims_supported\":[\"iss\",\"sub\",\"aud\",\"iat\",\"exp\",\"jti\",\"name\",\"family_name\",\"given_name\",\"preferred_username\"],\"request_uri_parameter_supported\":false}", + "headers" : { + "x-request-id" : "4a057ef7-5dc5-99ff-a979-a1ee19834830", + "date" : "Thu, 4 Dec 2025 04:50:55 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "vary" : "Accept-Encoding", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/json; charset=UTF-8", + "server-timing" : "request_id;dur=0;desc=\"4a057ef7-5dc5-49ff-a979-a1ee19834830\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "9fe698af-5c02-43cf-83e0-88c1407c1ee2", + "insertionIndex" : 15 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0ea7ed52-f6d8-4110-9877-a80cdc6bdaf4.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0ea7ed52-f6d8-4110-9877-a80cdc6bdaf4.json new file mode 100644 index 000000000..32fbd2380 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0ea7ed52-f6d8-4110-9877-a80cdc6bdaf4.json @@ -0,0 +1,35 @@ +{ + "id" : "0ea7ed52-f6d8-4110-9877-a80cdc6bdaf4", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAtPcGVuU2Vzc2lvbgAAAAEMAAEIAAH////5DQAECwsAAAAACgUCAAAAAAAApQkMBQQLAAEAAAAFU1BBUksLAAIAAAAHZGVmYXVsdAACBQUBAAA=" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAAtPcGVuU2Vzc2lvbgAAAAEMAAAMAAEIAAEAAAAAAAgAAgAApQgMAAMMAAELAAEAAAAQ7+OkU1rOQkGlxN9HIixDVAsAAgAAABAH/U7RXpRMP5FJdRcHu47SBg0BAAAACA0BAAClCAANAAQLCwAAAAAMBQQLAAEAAAAFc3BhcmsLAAIAAAAHZGVmYXVsdAACBQUBAAA=", + "headers" : { + "x-request-id" : "0a944bff-3159-908e-843c-6f825d8a03c8", + "date" : "Thu, 04 Dec 2025 04:50:57 GMT,Thu, 04 Dec 2025 04:50:57 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"0a944bff-3159-408e-843c-6f825d8a03c8\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "0ea7ed52-f6d8-4110-9877-a80cdc6bdaf4", + "insertionIndex" : 14 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0f78494f-401f-4527-98b6-ce7d1d7070a2.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0f78494f-401f-4527-98b6-ce7d1d7070a2.json new file mode 100644 index 000000000..cd93c48ac --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-0f78494f-401f-4527-98b6-ce7d1d7070a2.json @@ -0,0 +1,35 @@ +{ + "id" : "0f78494f-401f-4527-98b6-ce7d1d7070a2", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAIDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAAAAAAAAAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAAxGZXRjaFJlc3VsdHMAAAAIDAAADAABCAABAAAAAAACAAIBDAADCgABAAAAAAAAAAAPAAIMAAAAAA8FAgwAAAATCwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAwWl80YWEyY2M3YS1lNWYxLTQ4YjYtYjlkMS0wYWM0NGY5NDE5MjE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTgzMTU0NjhlZWI4MjNkN2Y4ZjZjZWZiMDFjY2UzYTk3ZjNiMDRiZjVmOWIwMDdhNjA1YjY3ZjE0NTg0MTE0MWUKAAIAAAGa58E4VQoAAwAAAAAAAAAACgAEAAAAAAAB4AAKAAUAAAAAAUCiwA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDFaXzdkMTY5ODlhLTYyZWUtNDJiNC1hOWZmLTE3ZTI4NGIxOWUyNj9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9NjgzZDE0ZjExOWMzMDM0MTc1YmNiYTg1NTY1ZTYxMzI4NTEzOTFiZjRlYjQyZGI4MjJlOTgyNzk4ZjYzMDU5YwoAAgAAAZrnwThVCgADAAAAAAAB4AAKAAQAAAAAAAHgAAoABQAAAAABQLAwDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwMVpfYjAwNWQ2MWYtNmUwMy00ZDY2LTlkNGMtNmJmZjQ1ZjliODFiP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT05MWM0NzA3NjFjMzk0NTliNmFiN2JjODZhYzA0ODMwN2NhZjE0NDU1YmI0NTc1MWM2ZWI2NWZmNzJiMmVjZGFkCgACAAABmufBOFUKAAMAAAAAAAPAAAoABAAAAAAAAeAACgAFAAAAAAFAi4gNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAyWl85NTE5ZWI2Yy1kMWZhLTQ2NDQtOTMwMS1mNGQyNjk3ZmMwMmI/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTJhZTJjMTZkYTlmM2JjYzFkY2ZkNGYzZmZlN2FhOTY2M2FhNmQ0NDE0ODhjODNjNzNhZTFhMzIxYjUwMDUxODAKAAIAAAGa58E4VQoAAwAAAAAABaAACgAEAAAAAAAB4AAKAAUAAAAAAUC1CA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDJaX2JlY2FkNjViLTQ2MTMtNGVhMS05M2RkLThhZDRjMzE0ZGRkOT9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9NTdhODUxNTg4MzRiZGE0NDA3YjQ3OTc4ZDc4MzZkNzhkMDhiZDE0MzgwMGRmYmJhMTg2OWRmMmYwNTJmYWE4ZgoAAgAAAZrnwThVCgADAAAAAAAHgAAKAAQAAAAAAAHgAAoABQAAAAABQLCgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwMlpfYmExN2MzZmQtZTA3Zi00MDE5LTk5YmUtMWFlZGZjMTFhZWRmP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0yYjI5OWM4N2E5MmU2YTI2NTJlZTg1ZDdmODU0YTRmYThjYzdmZjlkNDMwMzQxMWQxMWQ3ZjhjZDUzMGZmNDU1CgACAAABmufBOFUKAAMAAAAAAAlgAAoABAAAAAAAAeAACgAFAAAAAAFAocgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAzWl83NTVmNWI4YS01ZTBhLTRhMzctODk0My1jZjM0YWNmYzJjYzE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPWZlYTI1MWQ3MGUzM2E4MWMwZjc0MmI5NWFkMjliYWY2MzA1YmE4MDkxYjBhYzRiMTU4YmU0YjI3M2QyN2VjMGYKAAIAAAGa58E4VQoAAwAAAAAAC0AACgAEAAAAAAAB4AAKAAUAAAAAAUC+CA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDNaXzBjN2Q1YzdlLWFkN2MtNGE3ZS1hMWI4LTBjNzgzM2VlNDcyMD9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9MzBiMTkxNzY5MzMwMjIzNmVlNDRiYjQxNDIwMDc0M2NkNGRjZWYyYTZhZGQ3NzMxOTllMGJmNzc0ZDg2NWZjOAoAAgAAAZrnwThVCgADAAAAAAANIAAKAAQAAAAAAAHgAAoABQAAAAABQLWgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNFpfZDFjN2JlMTAtZTYwNS00YWE1LTlhODQtNDZkNTEzY2Y1OGJhP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0xNDE5M2Y5Y2E0NzRlNjZiYjhiNGM0ZmQ1ZDQwOWJlMGEyZjQzMWNkNTQ0ZDNkODA4ZmIyMTdjNTI5NTQ5NDA2CgACAAABmufBOFUKAAMAAAAAAA8AAAoABAAAAAAAAeAACgAFAAAAAAFAwcgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA0Wl81ZDgyMGJkZi0xMWY5LTQzMDItODk1My03ZDBlNmNmMTZiMDU/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTI1MjU4M2RkNTc0ZDRjMjZlNDZhNTFmN2RkNzA1ZTJkZTNkNjBkZDUyNmIwYmE0MjJjYTk4NWExYzcyMmJjNjAKAAIAAAGa58E4VQoAAwAAAAAAEOAACgAEAAAAAAAB4AAKAAUAAAAAAUC8EA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDVaX2Q3NjMyYzVlLWRhNjctNDNiMC04NmNkLTRhNjc0NmJmMzU3Mz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9YjcyNjYzMDg5Yjc2MzA0ODY0ZjExMmQ1OTM1MmEyNzg0MDFjODZhMjY5ZGIzODM4NDY0NTcxMjdkNjFhZjIzMwoAAgAAAZrnwThVCgADAAAAAAASwAAKAAQAAAAAAAHgAAoABQAAAAABQLyADQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNVpfY2RiNjlhZTgtOTNkYS00NWY0LWI4OTItMjNiMmYwMTkyZGU2P1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT00Zjk1YjU0MzRkNGEwYjI5MDFhYTgxOWNkOTNkMTIzMTk2N2JkY2MwN2JlMDdiZWUxMzUxOTFmNDdkMTQ1MDg1CgACAAABmufBOFUKAAMAAAAAABSgAAoABAAAAAAAAeAACgAFAAAAAAFAsKgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA1Wl9lOGMyNWU3Mi04MmZjLTQ1MDItYTNkMy1hZjE1YThjODBmM2I/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPWE1N2U3OWQxY2UxMzgwNTM1YjQ0YTgwZWQ5OTUzZTk0OWUwMGU1NzVhZWFhNjhmZGMzZGQ2M2E5ZDk5NzQyZjIKAAIAAAGa58E4VQoAAwAAAAAAFoAACgAEAAAAAAAB4AAKAAUAAAAAAUDGcA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDZaX2Y0MDdlZmRkLTNiMTctNDFhNS1hYjNjLTJhMjE1YWE3YWQ3Mz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9ZjY4YjM2MjMyNWY0MGQ0MzkyZWYwZDNkZjkyNTI0MTE4YmYzZTY1MTJhNmZhOTU5MGYwY2I2NDdkMTA2ODI1NwoAAgAAAZrnwThVCgADAAAAAAAYYAAKAAQAAAAAAAHgAAoABQAAAAABQMCIDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNlpfZTA2ZGIyZjQtODRkZC00NzFhLWJiMTUtYzdhZTZjODFhZDExP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT1lYWRiYzMzMWRlZGEwZjM0N2YxMjZhZmYxZjdhNzI5ZGFkY2JiZmMxOWE4ZmVhNzU4NGM3MTJmMTMxMGYzOGZmCgACAAABmufBOFUKAAMAAAAAABpAAAoABAAAAAAAAeAACgAFAAAAAAFAwQgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA3Wl9kZmY3ZDk2OC1kNWIzLTRlZDktOTI1NC0xZWNiMDk0MTQ0OWE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTZkN2YzMTMwOGEyZDE2MmFhNjkyNTMwMmVmMjliNGNhNzk1ZDc1NWIxZDU2NDgzNTlkNzE0YzJjM2IxMjRjYjgKAAIAAAGa58E4VQoAAwAAAAAAHCAACgAEAAAAAAAB4AAKAAUAAAAAAUCqEA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDdaX2U0ZjFiNDNjLThiNjItNGJmNC1iNGQ0LWRiZDYwNjQwYzMzYz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMzFaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9OWRiNTE2ZDgzNWNlZWI1YTQxZTRmMTNiN2YwNTVkZDc5YjRlZGI4Nzg3MGEyZmM2MzExOGU1OTIyMjM0N2ViZQoAAgAAAZrnwThVCgADAAAAAAAeAAAKAAQAAAAAAACHPwoABQAAAAAAWmGgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwN1pfMTIwNDQ4NDItYWQ4Mi00YmY0LTk1ZmEtNzViNDkyYjA4NWE4P1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEzMVomWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0zOGMzODU0OTc5MWE2NzRjNDVlNjUxYzg3ZmZiNWY1Y2MxYjVjZDE4NDZmZTc5ZjljNGExM2JiNmRkNjlmOTM0CgACAAABmufBOFUKAAMAAAAAAB6HPwoABAAAAAAAAeAACgAFAAAAAAFAnogNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA4Wl81Y2IxMjIyYy0zYzgwLTQ1MzgtYjY4Mi1iODk2ZGU5YzgwNDI/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTMxWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTQwMjdiNmU1MzdmYzA3NGZiMDEwZTcxZjZjOWFlNTBlM2Y2M2FmZTM3ZWY3Zjk0MjRkODQ0YmNlNzA1MDUxMWUKAAIAAAGa58E4VQoAAwAAAAAAIGc/CgAEAAAAAAAB4AAKAAUAAAAAAUC96A0ABgsLAAAAAAAAAAA=", + "headers" : { + "x-request-id" : "317854c4-769c-9291-a92e-1a9f57215c94", + "date" : "Thu, 04 Dec 2025 04:51:31 GMT,Thu, 04 Dec 2025 04:51:31 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"317854c4-769c-4291-a92e-1a9f57215c94\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "0f78494f-401f-4527-98b6-ce7d1d7070a2", + "insertionIndex" : 7 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-23067ce8-6bce-4cb1-8980-34af81201396.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-23067ce8-6bce-4cb1-8980-34af81201396.json new file mode 100644 index 000000000..7b0723d95 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-23067ce8-6bce-4cb1-8980-34af81201396.json @@ -0,0 +1,35 @@ +{ + "id" : "23067ce8-6bce-4cb1-8980-34af81201396", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAJDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAAAvZz8AAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "160e2644-c947-95a5-bf15-c8e0a4a436e6", + "date" : "Thu, 04 Dec 2025 04:51:33 GMT,Thu, 04 Dec 2025 04:51:33 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"160e2644-c947-45a5-bf15-c8e0a4a436e6\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "23067ce8-6bce-4cb1-8980-34af81201396", + "insertionIndex" : 6 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-27c64fb0-7c8e-40f4-94d3-e4ecb7878142.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-27c64fb0-7c8e-40f4-94d3-e4ecb7878142.json new file mode 100644 index 000000000..619485e8e --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-27c64fb0-7c8e-40f4-94d3-e4ecb7878142.json @@ -0,0 +1,35 @@ +{ + "id" : "27c64fb0-7c8e-40f4-94d3-e4ecb7878142", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAABBFeGVjdXRlU3RhdGVtZW50AAAAAgwAAQwAAQwAAQsAAQAAABDv46RTWs5CQaXE30ciLENUCwACAAAAEAf9TtFelEw/kUl1Fwe7jtIAAAsAAgAAADFTRUxFQ1QgKiBGUk9NIHNhbXBsZXMudHBjaC5saW5laXRlbSBMSU1JVCA2MDAwMDAwCgAFAAAAAAAAAAACBQIBAgUDAQIFBAEMBQYCAAEBAgACAQIAAwECAAQBAgAFAQAKBQcAAAAAAFuNgA8FCAwAAAAAAAA=" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAABBFeGVjdXRlU3RhdGVtZW50AAAAAgwAAAwAAQgAAQAAAAAADAACDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wYNAQAAAAgAAgAAAAACAAMBAAAA", + "headers" : { + "x-request-id" : "182ae382-07d1-9b96-bb03-fdd6156b6aed", + "date" : "Thu, 04 Dec 2025 04:50:58 GMT,Thu, 04 Dec 2025 04:51:20 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"182ae382-07d1-4b96-bb03-fdd6156b6aed\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "27c64fb0-7c8e-40f4-94d3-e4ecb7878142", + "insertionIndex" : 13 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-307d7eb4-b6b3-4954-9014-22bfc7a5bf5e.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-307d7eb4-b6b3-4954-9014-22bfc7a5bf5e.json new file mode 100644 index 000000000..1ba6149ad --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-307d7eb4-b6b3-4954-9014-22bfc7a5bf5e.json @@ -0,0 +1,35 @@ +{ + "id" : "307d7eb4-b6b3-4954-9014-22bfc7a5bf5e", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAFDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMAAgUDAQAA" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "9023fd39-f337-9997-a6ad-a2d45305f34f", + "date" : "Thu, 04 Dec 2025 04:51:25 GMT,Thu, 04 Dec 2025 04:51:25 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"9023fd39-f337-4997-a6ad-a2d45305f34f\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "307d7eb4-b6b3-4954-9014-22bfc7a5bf5e", + "insertionIndex" : 10 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-5951ffcd-aca8-4ef6-a37b-2551a4056961.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-5951ffcd-aca8-4ef6-a37b-2551a4056961.json new file mode 100644 index 000000000..091201da3 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-5951ffcd-aca8-4ef6-a37b-2551a4056961.json @@ -0,0 +1,35 @@ +{ + "id" : "5951ffcd-aca8-4ef6-a37b-2551a4056961", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAHDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAAAthz8AAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "8220dbf4-dccd-9c51-9ea1-51c6b660d824", + "date" : "Thu, 04 Dec 2025 04:51:29 GMT,Thu, 04 Dec 2025 04:51:29 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"8220dbf4-dccd-4c51-9ea1-51c6b660d824\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "5951ffcd-aca8-4ef6-a37b-2551a4056961", + "insertionIndex" : 8 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-66c9ef8e-cbba-42a4-bcf6-272d9e117e31.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-66c9ef8e-cbba-42a4-bcf6-272d9e117e31.json new file mode 100644 index 000000000..c89a9c40d --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-66c9ef8e-cbba-42a4-bcf6-272d9e117e31.json @@ -0,0 +1,35 @@ +{ + "id" : "66c9ef8e-cbba-42a4-bcf6-272d9e117e31", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAMDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAAAB4AAAAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "a190dcc1-5f92-9ba1-9140-913a8aeedd59", + "date" : "Thu, 04 Dec 2025 04:51:38 GMT,Thu, 04 Dec 2025 04:51:38 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"a190dcc1-5f92-4ba1-9140-913a8aeedd59\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "66c9ef8e-cbba-42a4-bcf6-272d9e117e31", + "insertionIndex" : 3 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-67e9f752-48c6-4b70-b65a-849bcf059e0b.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-67e9f752-48c6-4b70-b65a-849bcf059e0b.json new file mode 100644 index 000000000..0e02ea6f5 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-67e9f752-48c6-4b70-b65a-849bcf059e0b.json @@ -0,0 +1,35 @@ +{ + "id" : "67e9f752-48c6-4b70-b65a-849bcf059e0b", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxDbG9zZVNlc3Npb24AAAAODAABDAABDAABCwABAAAAEO/jpFNazkJBpcTfRyIsQ1QLAAIAAAAQB/1O0V6UTD+RSXUXB7uO0gAAAAA=" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAAxDbG9zZVNlc3Npb24AAAAODAAADAABCAABAAAAAAAAAA==", + "headers" : { + "x-request-id" : "524eec49-6769-921a-b00a-fce8fe490ee3", + "date" : "Thu, 04 Dec 2025 04:51:42 GMT,Thu, 04 Dec 2025 04:51:42 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"524eec49-6769-421a-b00a-fce8fe490ee3\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "67e9f752-48c6-4b70-b65a-849bcf059e0b", + "insertionIndex" : 1 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-86c2a8c7-d185-4fc9-b38a-2adec584b33b.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-86c2a8c7-d185-4fc9-b38a-2adec584b33b.json new file mode 100644 index 000000000..0478e5fe1 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-86c2a8c7-d185-4fc9-b38a-2adec584b33b.json @@ -0,0 +1,35 @@ +{ + "id" : "86c2a8c7-d185-4fc9-b38a-2adec584b33b", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAA5DbG9zZU9wZXJhdGlvbgAAAA0MAAEMAAEMAAELAAEAAAAQgLd1DzI7TsileMzohVK7WAsAAgAAABCJZfvzwwRF94zm6DtkWiz7AAgAAgAAAAgCAAMAAAAA" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAA5DbG9zZU9wZXJhdGlvbgAAAA0MAAAMAAEIAAEAAAAAAAAA", + "headers" : { + "x-request-id" : "1a241ac7-3f46-91bb-9bc4-dd2169a87433", + "date" : "Thu, 04 Dec 2025 04:51:40 GMT,Thu, 04 Dec 2025 04:51:40 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"1a241ac7-3f46-41bb-9bc4-dd2169a87433\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "86c2a8c7-d185-4fc9-b38a-2adec584b33b", + "insertionIndex" : 2 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-878a1d41-7921-431d-9550-a6bd3322de16.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-878a1d41-7921-431d-9550-a6bd3322de16.json new file mode 100644 index 000000000..f164bfb76 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-878a1d41-7921-431d-9550-a6bd3322de16.json @@ -0,0 +1,35 @@ +{ + "id" : "878a1d41-7921-431d-9550-a6bd3322de16", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAGDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMAAgUDAQAA" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "3fe87592-a22a-9366-bbff-67014e4a8614", + "date" : "Thu, 04 Dec 2025 04:51:27 GMT,Thu, 04 Dec 2025 04:51:27 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"3fe87592-a22a-4366-bbff-67014e4a8614\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "878a1d41-7921-431d-9550-a6bd3322de16", + "insertionIndex" : 9 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-a3fa77db-39ac-476f-ac3f-4569c6e79c94.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-a3fa77db-39ac-476f-ac3f-4569c6e79c94.json new file mode 100644 index 000000000..e52f8c92d --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-a3fa77db-39ac-476f-ac3f-4569c6e79c94.json @@ -0,0 +1,35 @@ +{ + "id" : "a3fa77db-39ac-476f-ac3f-4569c6e79c94", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAABJHZXRPcGVyYXRpb25TdGF0dXMAAAADDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAAAgADAQACAAIAAAA=" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAABJHZXRPcGVyYXRpb25TdGF0dXMAAAADDAAADAABCAABAAAAAAAIAAIAAAACCA0CAAAAAAAA", + "headers" : { + "x-request-id" : "f929d679-97bf-936c-b30e-f20e22864316", + "date" : "Thu, 04 Dec 2025 04:51:21 GMT,Thu, 04 Dec 2025 04:51:21 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"f929d679-97bf-436c-b30e-f20e22864316\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "a3fa77db-39ac-476f-ac3f-4569c6e79c94", + "insertionIndex" : 12 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-b5612470-09ce-4e6b-b413-c4bf6c48601d.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-b5612470-09ce-4e6b-b413-c4bf6c48601d.json new file mode 100644 index 000000000..29e80a98c --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-b5612470-09ce-4e6b-b413-c4bf6c48601d.json @@ -0,0 +1,35 @@ +{ + "id" : "b5612470-09ce-4e6b-b413-c4bf6c48601d", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAKDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAABZtz8AAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAAxGZXRjaFJlc3VsdHMAAAAKDAAADAABCAABAAAAAAACAAIADAADCgABAAAAAABZtz8PAAIMAAAAAA8FAgwAAAABCwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA4Wl81ZGJkMDJkNy01OGVlLTRkODgtYTgwNi04MWZhOWFhNTA5OTQ/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTM1WiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPThjNzBkYjNiZWI0ZTc0ZWM1M2ZhZTlhZDI3YTM0YjhlZDFmOWNkNjlmZmU3NDBkNjFmNWIzMjVjODA3OGQxNGQKAAIAAAGa58FHvAoAAwAAAAAAWbc/CgAEAAAAAAAB1kEKAAUAAAAAAUCwWA0ABgsLAAAAAAAAAAA=", + "headers" : { + "x-request-id" : "d0a9900a-28bd-9dfb-86f4-e057bb746316", + "date" : "Thu, 04 Dec 2025 04:51:35 GMT,Thu, 04 Dec 2025 04:51:35 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"d0a9900a-28bd-4dfb-86f4-e057bb746316\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "b5612470-09ce-4e6b-b413-c4bf6c48601d", + "insertionIndex" : 5 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-dba8b763-5fd0-4894-92bd-71f8df65817e.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-dba8b763-5fd0-4894-92bd-71f8df65817e.json new file mode 100644 index 000000000..0cbfc6436 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-dba8b763-5fd0-4894-92bd-71f8df65817e.json @@ -0,0 +1,35 @@ +{ + "id" : "dba8b763-5fd0-4894-92bd-71f8df65817e", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAAEDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAAAgADAQAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMAAgUDAQAA" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "gAEAAgAAAAxGZXRjaFJlc3VsdHMAAAAEDAAADAABCAABAAAAAAACAAIBDAADCgABAAAAAAAAAAAPAAIMAAAAAA8FAgwAAAATCwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAwWl80YWEyY2M3YS1lNWYxLTQ4YjYtYjlkMS0wYWM0NGY5NDE5MjE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPWFlMDNhMjI2MjI2MGY3N2EyYTMyNDY0NzE4ZjgyZGFlNzk5NGM3ZWY2MWViZjEwMTkwNjIzNmM0OTRlNGMzOTEKAAIAAAGa58EZQAoAAwAAAAAAAAAACgAEAAAAAAAB4AAKAAUAAAAAAUCiwA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDFaXzdkMTY5ODlhLTYyZWUtNDJiNC1hOWZmLTE3ZTI4NGIxOWUyNj9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9MTc0NGFmMThjZmJjYjIyOTYzNDBjOWE2NDA0Y2ZhZTMyZTkwNzZiN2E2MjMzMjhiNzZiNGIxNDMzZDA1YTI0MwoAAgAAAZrnwRlACgADAAAAAAAB4AAKAAQAAAAAAAHgAAoABQAAAAABQLAwDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwMVpfYjAwNWQ2MWYtNmUwMy00ZDY2LTlkNGMtNmJmZjQ1ZjliODFiP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT1kYjMxMzVkMTExZGJlMjkwNTc4ZGJhYTk0NzNlYWQ2Y2VhM2RlMTYzZjVlZjFiNTBiNTRkZGQzOTczYmE1OWM5CgACAAABmufBGUAKAAMAAAAAAAPAAAoABAAAAAAAAeAACgAFAAAAAAFAi4gNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAyWl85NTE5ZWI2Yy1kMWZhLTQ2NDQtOTMwMS1mNGQyNjk3ZmMwMmI/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPThhMDliZDdlNDlmNjFlMDRjZjIxMjUwZmVkZTljODE2NWFjMGU2ZjYwYmQ3ZjcyODhjMjVmYjU0ZjFiYmRhMzEKAAIAAAGa58EZQAoAAwAAAAAABaAACgAEAAAAAAAB4AAKAAUAAAAAAUC1CA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDJaX2JlY2FkNjViLTQ2MTMtNGVhMS05M2RkLThhZDRjMzE0ZGRkOT9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9MmE2N2Y1MTJmMDA5MWFmYTg2MTU0MzY2MDUxZmJlZDE5ODg1ZTIzNjU4OTI2OGY3Y2ViYmFmMDFmNWU0MTA4NgoAAgAAAZrnwRlACgADAAAAAAAHgAAKAAQAAAAAAAHgAAoABQAAAAABQLCgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwMlpfYmExN2MzZmQtZTA3Zi00MDE5LTk5YmUtMWFlZGZjMTFhZWRmP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0xOThlOGQ5NjFhMGI5MTI0NzY5Y2FhOTlmMDFmOTI2ZmVjM2JhZTUyNTMzMzNkZGI1M2RlM2FjYTk2ZTJmNWZkCgACAAABmufBGUAKAAMAAAAAAAlgAAoABAAAAAAAAeAACgAFAAAAAAFAocgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTAzWl83NTVmNWI4YS01ZTBhLTRhMzctODk0My1jZjM0YWNmYzJjYzE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTQwNzVjYmJhZjU5ZDg5MGU5YTViYzMzMmQ5NzM4OTE0M2ZlYjNiNWQ1Nzg3MmVhMzhjODAxZmJkYmQ2ZWNhN2IKAAIAAAGa58EZQAoAAwAAAAAAC0AACgAEAAAAAAAB4AAKAAUAAAAAAUC+CA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDNaXzBjN2Q1YzdlLWFkN2MtNGE3ZS1hMWI4LTBjNzgzM2VlNDcyMD9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9OTkyOTI5NmQ4ZDg3Njg2NDM4MmVlZWQ0Yjg1YmI2Mjc3NDU3ZTIyYWRkYmU5YWJjNTcxNTBkY2I3ZmY1ZTkzNwoAAgAAAZrnwRlACgADAAAAAAANIAAKAAQAAAAAAAHgAAoABQAAAAABQLWgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNFpfZDFjN2JlMTAtZTYwNS00YWE1LTlhODQtNDZkNTEzY2Y1OGJhP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT1jZjMyYWYyYmNlOTY5Yjc3MTc5ZDQ2MmQ5MmUxYjY3ZDI4ZjcxOGRmMjc3YTg3YThhNDUzY2Y4N2JiN2RhMzE1CgACAAABmufBGUAKAAMAAAAAAA8AAAoABAAAAAAAAeAACgAFAAAAAAFAwcgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA0Wl81ZDgyMGJkZi0xMWY5LTQzMDItODk1My03ZDBlNmNmMTZiMDU/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTBmZDZlZDJjZDUxNzdkZTAzZThkYWNhYzUyOGVlZjU5OWJhZWRmYmYzZTVmZGZlZmVlODMxN2YxMTEyZmZiNWMKAAIAAAGa58EZQAoAAwAAAAAAEOAACgAEAAAAAAAB4AAKAAUAAAAAAUC8EA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDVaX2Q3NjMyYzVlLWRhNjctNDNiMC04NmNkLTRhNjc0NmJmMzU3Mz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9YzY1ODc1YTc0YzA3NzEwNzJmNmJkM2I1YjY5MjliYjJlY2U1MjFjYWViNWEyOWI5NTA3MDhjNmU5NzY1NDQ0NgoAAgAAAZrnwRlACgADAAAAAAASwAAKAAQAAAAAAAHgAAoABQAAAAABQLyADQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNVpfY2RiNjlhZTgtOTNkYS00NWY0LWI4OTItMjNiMmYwMTkyZGU2P1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0zYzRhMGI3MzMxZTY2OTcxM2ZlMTIwNDUzNWEzNGRkZWNmMjk3M2M5Yjk3OGE2OGJiMzY5ZmI2ZDNmZGVmMDAxCgACAAABmufBGUAKAAMAAAAAABSgAAoABAAAAAAAAeAACgAFAAAAAAFAsKgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA1Wl9lOGMyNWU3Mi04MmZjLTQ1MDItYTNkMy1hZjE1YThjODBmM2I/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPWM4NzVmZTRmMTRiNTlkNTk0MTQ1ODQ0OGMzNTRlNDNlNjBjMzk5OTNhZGVjOTcyODM1ZjYwN2Y4ODk4ZjA1NzgKAAIAAAGa58EZQAoAAwAAAAAAFoAACgAEAAAAAAAB4AAKAAUAAAAAAUDGcA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDZaX2Y0MDdlZmRkLTNiMTctNDFhNS1hYjNjLTJhMjE1YWE3YWQ3Mz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9ZDUxYzM4NmNjZmEwNTJkZWVhOTM0ZTIxNWZkNDIxY2U2ODIxZDBkZDdhMDI4ZWMzYzhhNTM0YzEyYjdiODM0NwoAAgAAAZrnwRlACgADAAAAAAAYYAAKAAQAAAAAAAHgAAoABQAAAAABQMCIDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwNlpfZTA2ZGIyZjQtODRkZC00NzFhLWJiMTUtYzdhZTZjODFhZDExP1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT1kMDNjMjg5MDkzYWMzOTFmMmJlYzNkM2NiMjVmZmM2ZGVmODI0MWRiOTAwZmZlZDdiMTQyZGYzNmRkZTVlM2JiCgACAAABmufBGUAKAAMAAAAAABpAAAoABAAAAAAAAeAACgAFAAAAAAFAwQgNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA3Wl9kZmY3ZDk2OC1kNWIzLTRlZDktOTI1NC0xZWNiMDk0MTQ0OWE/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPWM2MDJlODQ0YjRjMTlhMjNjODQ3OTkwZTVlYzRhMjQ5ZGRhZDFlYmU0MmJhNjI0MDQ1MzJiMzRmMTgxYTQxNDcKAAIAAAGa58EZQAoAAwAAAAAAHCAACgAEAAAAAAAB4AAKAAUAAAAAAUCqEA0ABgsLAAAAAAALAAEAAAZPaHR0cHM6Ly9lMi1kb2dmb29kLWNvcmUuczMudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20vb3JlZ29uLXN0YWdpbmcvNjA1MTkyMTQxODQxODg5My5qb2JzL3NxbC8yMDI1LTEyLTA0LzA0L3Jlc3VsdHNfMjAyNS0xMi0wNFQwNCUzQTUxJTNBMDdaX2U0ZjFiNDNjLThiNjItNGJmNC1iNGQ0LWRiZDYwNjQwYzMzYz9YLUFtei1TZWN1cml0eS1Ub2tlbj1JUW9KYjNKcFoybHVYMlZqRUhVYURuVnpMWGRsYzNRdE1pMW1hWEJ6SWtjd1JRSWhBTmZIc2x3MG9JZExRSTFzMEw0MjlvdDhwJTJCT2tRakRjd0xZMCUyRnZCd1FKWU5BaUExeDJEdno3cUE4aVRCSjZaeGkzOWl2MlpOckg0ZWElMkZvOTMlMkZaaEhiRHJUeXJYQXdnJTJCRUFBYUREVTBPREV5TlRBM016RTJOaUlNS0ZDWTRnbUZ4SHVvTk5vdktyUURiTHRtZVhTR2dWc3Q2ME5XcjB5bXdaTUJaRm1GNUswOTJEWkZMTG5YOG5WVG80M3VzMkpwb3puUGtSTnJwbkw1NXhRdENscHdJJTJCODd1dHhmQVVFaWM3bSUyQjFkWk15dklFZktFdVFVeXM5elMzNlZmZ1cxOEREZE52R040JTJCMFB3QzFCdm0lMkZMNTN4QWQlMkZiJTJCRllZOGp5UzZOTEV3VSUyRlBPVzZtMVFnYnVGJTJCcXJUb1ozdVFsaEJDU011a3BuaU5PQ3RNaXNjNmNlVk1ibCUyQnZkUXRZamJPayUyQlNmZTFjM054NjZlVWh3czFia05OQ2gyckpvdiUyRnRqaEtpVlMxTllTeFE3dWdOZ2hxSVp1bzFqYjRvamY2eDBQaXVwV0ZNaWlCdVpNS0NhQzRqVUFhMzQlMkJtcWhTZU5xQUJXJTJCanljY05xT0JJRjBsY2FNSnJFMTczbWpURUdQTEtnaGZheE9UblFDT0MlMkJZMFlRUE9NOWNwQnFtRWxmSCUyRjVuZ1pYVzFua3RacW91Z1M4MFFQeGF5czdHU2VINXlodHlEMFJucUZFeFQxdGtnTEk5YW9wJTJCQUs4JTJGY1VTMmZ4Z1JVRTY5RW9Gb1g4WDRBdEZHM0QyVUlaakdGNEtuZVNpcHBCMVhJSlJXZVd2bkZ1SmVZcGIyM0psUyUyRld1Y2JaYUFYTUxiRnRlWWt6dUJPRkpjcUVrUTIxVVBQTTJ4Zk56UzdZa0RnQU4wM05lZ2pvc0FpMjlFRjlTSzlycjJ6WFZRViUyRkd1STAxcEkxcWJweDFyekRvb01USkJqcmlBVno4T21YU09tOFBKbWU3Q2x2bTQzMGdndDd5VmVDNWw3cHB2bDdPWm5BQlNxcmZJTTZXSjFuenZBSUIzcUhOT1ZITnh6cW1YZ1NTb2xOZWxPb0prV2wlMkJiYmdqaHk5JTJCbGdHeCUyQmF0NyUyQkd5VVZXV0RnY3d6ZVV1dlpYSjhkdnJTNjJ4c2pCc1dXYUNwd1NPTjJXaDJVZk5pRlVEdDhhNEtxY3VnQTNvOHJhOFZvRnBTaG5oJTJCQXpFaUJTaXFrWnd6VHhGcmZKJTJGRlh0UllpMnNvcUZvJTJGNGUxamhtalRlbnlrQTFjbHFZSnlDTUdtMHU4N0hmRUlCM242UjJxQW9WcHEwNnB4MVFIUkZCNEFuWVFiRkxZM25FMjFXcSUyQlh6VjNieHhTTWdnc04zdSUyQmQwczAlM0QmWC1BbXotQWxnb3JpdGhtPUFXUzQtSE1BQy1TSEEyNTYmWC1BbXotRGF0ZT0yMDI1MTIwNFQwNDUxMjNaJlgtQW16LVNpZ25lZEhlYWRlcnM9aG9zdCZYLUFtei1FeHBpcmVzPTg5OSZYLUFtei1DcmVkZW50aWFsPUFTSUFYN0hXTTM0SExNSUlHQ1c2JTJGMjAyNTEyMDQlMkZ1cy13ZXN0LTIlMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1TaWduYXR1cmU9MzU3YTE4MzdhMDFlYmMwMWIxNDg5M2M0ZDg5ZDllMTU1NWE3YzkzNTJhMzlmNTE3ZWJmYWM5YWQ5ODhlNDBkMAoAAgAAAZrnwRlACgADAAAAAAAeAAAKAAQAAAAAAACHPwoABQAAAAAAWmGgDQAGCwsAAAAAAAsAAQAABk9odHRwczovL2UyLWRvZ2Zvb2QtY29yZS5zMy51cy13ZXN0LTIuYW1hem9uYXdzLmNvbS9vcmVnb24tc3RhZ2luZy82MDUxOTIxNDE4NDE4ODkzLmpvYnMvc3FsLzIwMjUtMTItMDQvMDQvcmVzdWx0c18yMDI1LTEyLTA0VDA0JTNBNTElM0EwN1pfMTIwNDQ4NDItYWQ4Mi00YmY0LTk1ZmEtNzViNDkyYjA4NWE4P1gtQW16LVNlY3VyaXR5LVRva2VuPUlRb0piM0pwWjJsdVgyVmpFSFVhRG5WekxYZGxjM1F0TWkxbWFYQnpJa2N3UlFJaEFOZkhzbHcwb0lkTFFJMXMwTDQyOW90OHAlMkJPa1FqRGN3TFkwJTJGdkJ3UUpZTkFpQTF4MkR2ejdxQThpVEJKNlp4aTM5aXYyWk5ySDRlYSUyRm85MyUyRlpoSGJEclR5clhBd2clMkJFQUFhRERVME9ERXlOVEEzTXpFMk5pSU1LRkNZNGdtRnhIdW9OTm92S3JRRGJMdG1lWFNHZ1ZzdDYwTldyMHltd1pNQlpGbUY1SzA5MkRaRkxMblg4blZUbzQzdXMySnBvem5Qa1JOcnBuTDU1eFF0Q2xwd0klMkI4N3V0eGZBVUVpYzdtJTJCMWRaTXl2SUVmS0V1UVV5czl6UzM2VmZnVzE4RERkTnZHTjQlMkIwUHdDMUJ2bSUyRkw1M3hBZCUyRmIlMkJGWVk4anlTNk5MRXdVJTJGUE9XNm0xUWdidUYlMkJxclRvWjN1UWxoQkNTTXVrcG5pTk9DdE1pc2M2Y2VWTWJsJTJCdmRRdFlqYk9rJTJCU2ZlMWMzTng2NmVVaHdzMWJrTk5DaDJySm92JTJGdGpoS2lWUzFOWVN4UTd1Z05naHFJWnVvMWpiNG9qZjZ4MFBpdXBXRk1paUJ1Wk1LQ2FDNGpVQWEzNCUyQm1xaFNlTnFBQlclMkJqeWNjTnFPQklGMGxjYU1KckUxNzNtalRFR1BMS2doZmF4T1RuUUNPQyUyQlkwWVFQT005Y3BCcW1FbGZIJTJGNW5nWlhXMW5rdFpxb3VnUzgwUVB4YXlzN0dTZUg1eWh0eUQwUm5xRkV4VDF0a2dMSTlhb3AlMkJBSzglMkZjVVMyZnhnUlVFNjlFb0ZvWDhYNEF0RkczRDJVSVpqR0Y0S25lU2lwcEIxWElKUldlV3ZuRnVKZVlwYjIzSmxTJTJGV3VjYlphQVhNTGJGdGVZa3p1Qk9GSmNxRWtRMjFVUFBNMnhmTnpTN1lrRGdBTjAzTmVnam9zQWkyOUVGOVNLOXJyMnpYVlFWJTJGR3VJMDFwSTFxYnB4MXJ6RG9vTVRKQmpyaUFWejhPbVhTT204UEptZTdDbHZtNDMwZ2d0N3lWZUM1bDdwcHZsN09abkFCU3FyZklNNldKMW56dkFJQjNxSE5PVkhOeHpxbVhnU1NvbE5lbE9vSmtXbCUyQmJiZ2poeTklMkJsZ0d4JTJCYXQ3JTJCR3lVVldXRGdjd3plVXV2WlhKOGR2clM2MnhzakJzV1dhQ3B3U09OMldoMlVmTmlGVUR0OGE0S3FjdWdBM284cmE4Vm9GcFNobmglMkJBekVpQlNpcWtad3pUeEZyZkolMkZGWHRSWWkyc29xRm8lMkY0ZTFqaG1qVGVueWtBMWNscVlKeUNNR20wdTg3SGZFSUIzbjZSMnFBb1ZwcTA2cHgxUUhSRkI0QW5ZUWJGTFkzbkUyMVdxJTJCWHpWM2J4eFNNZ2dzTjN1JTJCZDBzMCUzRCZYLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1EYXRlPTIwMjUxMjA0VDA0NTEyM1omWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JlgtQW16LUV4cGlyZXM9ODk5JlgtQW16LUNyZWRlbnRpYWw9QVNJQVg3SFdNMzRITE1JSUdDVzYlMkYyMDI1MTIwNCUyRnVzLXdlc3QtMiUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LVNpZ25hdHVyZT0xOTE1NTRhN2I2OGI2NjBiMzkxZWY0ODNiMTRhMjEyYWU5MjNkMTBlYWQzZWViYTE2OTFlMDk1NDVhMDFmMzE4CgACAAABmufBGUAKAAMAAAAAAB6HPwoABAAAAAAAAeAACgAFAAAAAAFAnogNAAYLCwAAAAAACwABAAAGT2h0dHBzOi8vZTItZG9nZm9vZC1jb3JlLnMzLnVzLXdlc3QtMi5hbWF6b25hd3MuY29tL29yZWdvbi1zdGFnaW5nLzYwNTE5MjE0MTg0MTg4OTMuam9icy9zcWwvMjAyNS0xMi0wNC8wNC9yZXN1bHRzXzIwMjUtMTItMDRUMDQlM0E1MSUzQTA4Wl81Y2IxMjIyYy0zYzgwLTQ1MzgtYjY4Mi1iODk2ZGU5YzgwNDI/WC1BbXotU2VjdXJpdHktVG9rZW49SVFvSmIzSnBaMmx1WDJWakVIVWFEblZ6TFhkbGMzUXRNaTFtYVhCeklrY3dSUUloQU5mSHNsdzBvSWRMUUkxczBMNDI5b3Q4cCUyQk9rUWpEY3dMWTAlMkZ2QndRSllOQWlBMXgyRHZ6N3FBOGlUQko2WnhpMzlpdjJaTnJINGVhJTJGbzkzJTJGWmhIYkRyVHlyWEF3ZyUyQkVBQWFERFUwT0RFeU5UQTNNekUyTmlJTUtGQ1k0Z21GeEh1b05Ob3ZLclFEYkx0bWVYU0dnVnN0NjBOV3IweW13Wk1CWkZtRjVLMDkyRFpGTExuWDhuVlRvNDN1czJKcG96blBrUk5ycG5MNTV4UXRDbHB3SSUyQjg3dXR4ZkFVRWljN20lMkIxZFpNeXZJRWZLRXVRVXlzOXpTMzZWZmdXMThERGROdkdONCUyQjBQd0MxQnZtJTJGTDUzeEFkJTJGYiUyQkZZWThqeVM2TkxFd1UlMkZQT1c2bTFRZ2J1RiUyQnFyVG9aM3VRbGhCQ1NNdWtwbmlOT0N0TWlzYzZjZVZNYmwlMkJ2ZFF0WWpiT2slMkJTZmUxYzNOeDY2ZVVod3MxYmtOTkNoMnJKb3YlMkZ0amhLaVZTMU5ZU3hRN3VnTmdocUladW8xamI0b2pmNngwUGl1cFdGTWlpQnVaTUtDYUM0alVBYTM0JTJCbXFoU2VOcUFCVyUyQmp5Y2NOcU9CSUYwbGNhTUpyRTE3M21qVEVHUExLZ2hmYXhPVG5RQ09DJTJCWTBZUVBPTTljcEJxbUVsZkglMkY1bmdaWFcxbmt0WnFvdWdTODBRUHhheXM3R1NlSDV5aHR5RDBSbnFGRXhUMXRrZ0xJOWFvcCUyQkFLOCUyRmNVUzJmeGdSVUU2OUVvRm9YOFg0QXRGRzNEMlVJWmpHRjRLbmVTaXBwQjFYSUpSV2VXdm5GdUplWXBiMjNKbFMlMkZXdWNiWmFBWE1MYkZ0ZVlrenVCT0ZKY3FFa1EyMVVQUE0yeGZOelM3WWtEZ0FOMDNOZWdqb3NBaTI5RUY5U0s5cnIyelhWUVYlMkZHdUkwMXBJMXFicHgxcnpEb29NVEpCanJpQVZ6OE9tWFNPbThQSm1lN0Nsdm00MzBnZ3Q3eVZlQzVsN3Bwdmw3T1puQUJTcXJmSU02V0oxbnp2QUlCM3FITk9WSE54enFtWGdTU29sTmVsT29Ka1dsJTJCYmJnamh5OSUyQmxnR3glMkJhdDclMkJHeVVWV1dEZ2N3emVVdXZaWEo4ZHZyUzYyeHNqQnNXV2FDcHdTT04yV2gyVWZOaUZVRHQ4YTRLcWN1Z0EzbzhyYThWb0ZwU2huaCUyQkF6RWlCU2lxa1p3elR4RnJmSiUyRkZYdFJZaTJzb3FGbyUyRjRlMWpobWpUZW55a0ExY2xxWUp5Q01HbTB1ODdIZkVJQjNuNlIycUFvVnBxMDZweDFRSFJGQjRBbllRYkZMWTNuRTIxV3ElMkJYelYzYnh4U01nZ3NOM3UlMkJkMHMwJTNEJlgtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LURhdGU9MjAyNTEyMDRUMDQ1MTIzWiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmWC1BbXotRXhwaXJlcz04OTkmWC1BbXotQ3JlZGVudGlhbD1BU0lBWDdIV00zNEhMTUlJR0NXNiUyRjIwMjUxMjA0JTJGdXMtd2VzdC0yJTJGczMlMkZhd3M0X3JlcXVlc3QmWC1BbXotU2lnbmF0dXJlPTA4MDRmZWZlNjI2ODhmMDZmNzlhNGU0NGJhMGE5NzAwNTIyNDBmZmYzYmRhMzM3Y2QwMWFjZWUxZjQzNDUwNmIKAAIAAAGa58EZQAoAAwAAAAAAIGc/CgAEAAAAAAAB4AAKAAUAAAAAAUC96A0ABgsLAAAAAAAADAUBDAABCAABAAAAAAAMAAIPAAEMAAAAEAsAAQAAAApsX29yZGVya2V5DAACDwABDAAAAAEMAAEIAAEAAAAEAAAACAADAAAAAQsABAAAAAAACwABAAAACWxfcGFydGtleQwAAg8AAQwAAAABDAABCAABAAAABAAAAAgAAwAAAAILAAQAAAAAAAsAAQAAAAlsX3N1cHBrZXkMAAIPAAEMAAAAAQwAAQgAAQAAAAQAAAAIAAMAAAADCwAEAAAAAAALAAEAAAAMbF9saW5lbnVtYmVyDAACDwABDAAAAAEMAAEIAAEAAAADAAAACAADAAAABAsABAAAAAAACwABAAAACmxfcXVhbnRpdHkMAAIPAAEMAAAAAQwAAQgAAQAAAA8MAAINAAELDAAAAAIAAAAJcHJlY2lzaW9uCAABAAAAEgAAAAAFc2NhbGUIAAEAAAACAAAAAAAIAAMAAAAFCwAEAAAAAAALAAEAAAAPbF9leHRlbmRlZHByaWNlDAACDwABDAAAAAEMAAEIAAEAAAAPDAACDQABCwwAAAACAAAACXByZWNpc2lvbggAAQAAABIAAAAABXNjYWxlCAABAAAAAgAAAAAACAADAAAABgsABAAAAAAACwABAAAACmxfZGlzY291bnQMAAIPAAEMAAAAAQwAAQgAAQAAAA8MAAINAAELDAAAAAIAAAAJcHJlY2lzaW9uCAABAAAAEgAAAAAFc2NhbGUIAAEAAAACAAAAAAAIAAMAAAAHCwAEAAAAAAALAAEAAAAFbF90YXgMAAIPAAEMAAAAAQwAAQgAAQAAAA8MAAINAAELDAAAAAIAAAAJcHJlY2lzaW9uCAABAAAAEgAAAAAFc2NhbGUIAAEAAAACAAAAAAAIAAMAAAAICwAEAAAAAAALAAEAAAAMbF9yZXR1cm5mbGFnDAACDwABDAAAAAEMAAEIAAEAAAAHAAAACAADAAAACQsABAAAAAAACwABAAAADGxfbGluZXN0YXR1cwwAAg8AAQwAAAABDAABCAABAAAABwAAAAgAAwAAAAoLAAQAAAAAAAsAAQAAAApsX3NoaXBkYXRlDAACDwABDAAAAAEMAAEIAAEAAAARAAAACAADAAAACwsABAAAAAAACwABAAAADGxfY29tbWl0ZGF0ZQwAAg8AAQwAAAABDAABCAABAAAAEQAAAAgAAwAAAAwLAAQAAAAAAAsAAQAAAA1sX3JlY2VpcHRkYXRlDAACDwABDAAAAAEMAAEIAAEAAAARAAAACAADAAAADQsABAAAAAAACwABAAAADmxfc2hpcGluc3RydWN0DAACDwABDAAAAAEMAAEIAAEAAAAHAAAACAADAAAADgsABAAAAAAACwABAAAACmxfc2hpcG1vZGUMAAIPAAEMAAAAAQwAAQgAAQAAAAcAAAAIAAMAAAAPCwAEAAAAAAALAAEAAAAJbF9jb21tZW50DAACDwABDAAAAAEMAAEIAAEAAAAHAAAACAADAAAAEAsABAAAAAAAAAgFAQAAAAMCBQIBCwUDAAALqP////+gCwAAEAAAAAAACgAOAAYADQAIAAoAAAAAAAQAEAAAAAABCgAMAAAACAAEAAoAAAAIAAAACAAAAAAAAAAQAAAAqAoAAOgJAAA4CQAAhAgAAMQHAAAABwAAQAYAAIQFAADQBAAAIAQAAGwDAAC8AgAADAIAAFwBAACwAAAABAAAAKr1//8UAAAAiAAAAIgAAAAAAAUBhAAAAAIAAABAAAAABAAAAGT1//8IAAAAFAAAAAgAAAAic3RyaW5nIgAAAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUAnPX//wgAAAAQAAAABgAAAFNUUklORwAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAABQ+///CQAAAGxfY29tbWVudAAAAFL2//8UAAAAiAAAAIgAAAAAAAUBhAAAAAIAAABAAAAABAAAAAz2//8IAAAAFAAAAAgAAAAic3RyaW5nIgAAAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUARPb//wgAAAAQAAAABgAAAFNUUklORwAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAAD4+///CgAAAGxfc2hpcG1vZGUAAPr2//8UAAAAiAAAAIgAAAAAAAUBhAAAAAIAAABAAAAABAAAALT2//8IAAAAFAAAAAgAAAAic3RyaW5nIgAAAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUA7Pb//wgAAAAQAAAABgAAAFNUUklORwAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAACg/P//DgAAAGxfc2hpcGluc3RydWN0AACm9///FAAAAIQAAACEAAAAAAAIAYQAAAACAAAAPAAAAAQAAABg9///CAAAABAAAAAGAAAAImRhdGUiAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUAlPf//wgAAAAQAAAABAAAAERBVEUAAAAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAACm/v//AAAAAA0AAABsX3JlY2VpcHRkYXRlAAAAUvj//xQAAACEAAAAhAAAAAAACAGEAAAAAgAAADwAAAAEAAAADPj//wgAAAAQAAAABgAAACJkYXRlIgAAFwAAAFNwYXJrOkRhdGFUeXBlOkpzb25UeXBlAED4//8IAAAAEAAAAAQAAABEQVRFAAAAABYAAABTcGFyazpEYXRhVHlwZTpTcWxOYW1lAAAAAAAAUv///wAAAAAMAAAAbF9jb21taXRkYXRlAAAAAP74//8UAAAAhAAAAIwAAAAAAAgBjAAAAAIAAAA8AAAABAAAALj4//8IAAAAEAAAAAYAAAAiZGF0ZSIAABcAAABTcGFyazpEYXRhVHlwZTpKc29uVHlwZQDs+P//CAAAABAAAAAEAAAAREFURQAAAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAAAAABgAIAAYABgAAAAAAAAAKAAAAbF9zaGlwZGF0ZQAArvn//xQAAACIAAAAiAAAAAAABQGEAAAAAgAAAEAAAAAEAAAAaPn//wgAAAAUAAAACAAAACJzdHJpbmciAAAAABcAAABTcGFyazpEYXRhVHlwZTpKc29uVHlwZQCg+f//CAAAABAAAAAGAAAAU1RSSU5HAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAAFT///8MAAAAbF9saW5lc3RhdHVzAAAAAFr6//8UAAAAiAAAAIwAAAAAAAUBiAAAAAIAAABAAAAABAAAABT6//8IAAAAFAAAAAgAAAAic3RyaW5nIgAAAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUATPr//wgAAAAQAAAABgAAAFNUUklORwAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAAAEAAQABAAAAAwAAABsX3JldHVybmZsYWcAAAAACvv//xQAAACUAAAAlAAAAAAABwGYAAAAAgAAAEQAAAAEAAAAxPr//wgAAAAYAAAADwAAACJkZWNpbWFsKDE4LDIpIgAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUAAPv//wgAAAAYAAAADQAAAERFQ0lNQUwoMTgsMikAAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAAED7//8CAAAAEgAAAAUAAABsX3RheAAAAML7//8UAAAAlAAAAJQAAAAAAAcBmAAAAAIAAABEAAAABAAAAHz7//8IAAAAGAAAAA8AAAAiZGVjaW1hbCgxOCwyKSIAFwAAAFNwYXJrOkRhdGFUeXBlOkpzb25UeXBlALj7//8IAAAAGAAAAA0AAABERUNJTUFMKDE4LDIpAAAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAAD4+///AgAAABIAAAAKAAAAbF9kaXNjb3VudAAAfvz//xQAAACUAAAAlAAAAAAABwGYAAAAAgAAAEQAAAAEAAAAOPz//wgAAAAYAAAADwAAACJkZWNpbWFsKDE4LDIpIgAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUAdPz//wgAAAAYAAAADQAAAERFQ0lNQUwoMTgsMikAAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAALT8//8CAAAAEgAAAA8AAABsX2V4dGVuZGVkcHJpY2UAPv3//xQAAACUAAAAlAAAAAAABwGYAAAAAgAAAEQAAAAEAAAA+Pz//wgAAAAYAAAADwAAACJkZWNpbWFsKDE4LDIpIgAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUANP3//wgAAAAYAAAADQAAAERFQ0lNQUwoMTgsMikAAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAAHT9//8CAAAAEgAAAAoAAABsX3F1YW50aXR5AAD6/f//FAAAAIQAAACEAAAAAAACAYgAAAACAAAAQAAAAAQAAAC0/f//CAAAABQAAAAJAAAAImludGVnZXIiAAAAFwAAAFNwYXJrOkRhdGFUeXBlOkpzb25UeXBlAOz9//8IAAAADAAAAAMAAABJTlQAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAADg/f//AAAAASAAAAAMAAAAbF9saW5lbnVtYmVyAAAAAKr+//8UAAAAhAAAAIQAAAAAAAIBiAAAAAIAAAA8AAAABAAAAGT+//8IAAAAEAAAAAYAAAAibG9uZyIAABcAAABTcGFyazpEYXRhVHlwZTpKc29uVHlwZQCY/v//CAAAABAAAAAGAAAAQklHSU5UAAAWAAAAU3Bhcms6RGF0YVR5cGU6U3FsTmFtZQAAAAAAAJD+//8AAAABQAAAAAkAAABsX3N1cHBrZXkAAABW////FAAAAIQAAACEAAAAAAACAYgAAAACAAAAPAAAAAQAAAAQ////CAAAABAAAAAGAAAAImxvbmciAAAXAAAAU3Bhcms6RGF0YVR5cGU6SnNvblR5cGUARP///wgAAAAQAAAABgAAAEJJR0lOVAAAFgAAAFNwYXJrOkRhdGFUeXBlOlNxbE5hbWUAAAAAAAA8////AAAAAUAAAAAJAAAAbF9wYXJ0a2V5ABIAGAAUABMAEgAMAAAACAAEABIAAAAUAAAAjAAAAJQAAAAAAAIBmAAAAAIAAABEAAAABAAAAMz///8IAAAAEAAAAAYAAAAibG9uZyIAABcAAABTcGFyazpEYXRhVHlwZTpKc29uVHlwZQAIAAwACAAEAAgAAAAIAAAAEAAAAAYAAABCSUdJTlQAABYAAABTcGFyazpEYXRhVHlwZTpTcWxOYW1lAAAAAAAACAAMAAgABwAIAAAAAAAAAUAAAAAKAAAAbF9vcmRlcmtleQAACAUEAAAAAAoFBQAAAABeeQNYCgUGAAAAACRnQ0ACBQcACA0BAAAACAoNBQAAAAAAAAAAAg0RAAINEwAAAAA=", + "headers" : { + "x-request-id" : "78c6fbb8-9d4d-9390-880d-4207b59b70dc", + "date" : "Thu, 04 Dec 2025 04:51:22 GMT,Thu, 04 Dec 2025 04:51:23 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"78c6fbb8-9d4d-4390-880d-4207b59b70dc\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "dba8b763-5fd0-4894-92bd-71f8df65817e", + "insertionIndex" : 11 +} \ No newline at end of file diff --git a/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-f1f68bae-b7ed-4a55-8e80-09e5305b24a8.json b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-f1f68bae-b7ed-4a55-8e80-09e5305b24a8.json new file mode 100644 index 000000000..2a8588817 --- /dev/null +++ b/src/test/resources/thriftserverapi/thriftcloudfetchfakeintegrationtests/testcloudfetchlinksrefetchatstartrowoffset/mappings/sql_protocolv1_o_6051921418418893_0819-204509-hill72-f1f68bae-b7ed-4a55-8e80-09e5305b24a8.json @@ -0,0 +1,35 @@ +{ + "id" : "f1f68bae-b7ed-4a55-8e80-09e5305b24a8", + "name" : "sql_protocolv1_o_6051921418418893_0819-204509-hill72", + "request" : { + "url" : "/sql/protocolv1/o/6051921418418893/0819-204509-hill72", + "method" : "POST", + "bodyPatterns" : [ { + "binaryEqualTo" : "gAEAAQAAAAxGZXRjaFJlc3VsdHMAAAALDAABDAABDAABCwABAAAAEIC3dQ8yO07IpXjM6IVSu1gLAAIAAAAQiWX788MERfeM5ug7ZFos+wAIAAIAAAAIAgADAAAIAAIAAAAACgADAAAAAAAehIAGAAQAAAoFAQAAAAAYIaMACgUCAAAAAAArpz8AAA==" + } ] + }, + "response" : { + "status" : 200, + "base64Body" : "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", + "headers" : { + "x-request-id" : "9b926525-99b4-9b09-89a8-734eed186822", + "date" : "Thu, 04 Dec 2025 04:51:36 GMT,Thu, 04 Dec 2025 04:51:36 GMT", + "server" : "databricks", + "x-databricks-popp-response-code-details" : "via_upstream", + "x-databricks-shard-debug" : "oregon-staging", + "x-frame-options" : "SAMEORIGIN", + "x-databricks-popp-shadow-routing-reason" : "spog-domain-checker-false", + "x-databricks-org-id" : "6051921418418893", + "strict-transport-security" : "max-age=31536000; includeSubDomains; preload", + "x-content-type-options" : "nosniff", + "x-xss-protection" : "1; mode=block", + "x-databricks-popp-routing-reason" : "deployment-name", + "content-type" : "application/x-thrift", + "server-timing" : "request_id;dur=0;desc=\"9b926525-99b4-4b09-89a8-734eed186822\", client_protocol;dur=0;desc=\"HTTP/1.1\"", + "alt-svc" : "h3=\":5443\"; ma=86400, h3-29=\":5443\"; ma=86400", + "x-databricks-apiproxy-response-code-details" : "via_upstream" + } + }, + "uuid" : "f1f68bae-b7ed-4a55-8e80-09e5305b24a8", + "insertionIndex" : 4 +} \ No newline at end of file