From 6621252e70ebf44ed0ffcb6043a12db856db289f Mon Sep 17 00:00:00 2001 From: Erik Marks Date: Fri, 17 Jan 2025 21:39:34 -0800 Subject: [PATCH 01/55] refactor: Move sqlite-wasm code to extension --- packages/extension/package.json | 1 + packages/extension/src/iframe.ts | 3 +++ .../src/kernel-integration/kernel-worker.ts | 3 ++- .../src/kernel-integration}/sqlite-kv-store.ts | 11 +---------- packages/kernel/package.json | 1 - packages/kernel/src/Kernel.test.ts | 2 +- packages/kernel/src/Kernel.ts | 3 +-- packages/kernel/src/VatSupervisor.test.ts | 2 ++ packages/kernel/src/VatSupervisor.ts | 10 +++++++--- packages/kernel/src/index.test.ts | 1 - packages/kernel/src/index.ts | 3 +-- packages/kernel/src/store/kernel-store.test.ts | 2 +- packages/kernel/src/store/kernel-store.ts | 16 +++++++++++++++- packages/kernel/src/syscall.ts | 2 +- packages/kernel/test/storage.ts | 2 +- packages/nodejs/src/vat/vat-worker.ts | 3 +++ vitest.config.ts | 16 ++++++++-------- yarn.lock | 10 +++++----- 18 files changed, 53 insertions(+), 38 deletions(-) rename packages/{kernel/src/store => extension/src/kernel-integration}/sqlite-kv-store.ts (94%) diff --git a/packages/extension/package.json b/packages/extension/package.json index f3879c653..bf5c6a8df 100644 --- a/packages/extension/package.json +++ b/packages/extension/package.json @@ -53,6 +53,7 @@ "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", + "@sqlite.org/sqlite-wasm": "^3.48.0-build1", "react": "^18.3.1", "react-dom": "^18.3.1", "ses": "^1.9.0" diff --git a/packages/extension/src/iframe.ts b/packages/extension/src/iframe.ts index fd8a563cd..a8b2f04b3 100644 --- a/packages/extension/src/iframe.ts +++ b/packages/extension/src/iframe.ts @@ -2,6 +2,8 @@ import { isVatCommand, VatSupervisor } from '@ocap/kernel'; import type { VatCommand, VatCommandReply } from '@ocap/kernel'; import { MessagePortMultiplexer, receiveMessagePort } from '@ocap/streams'; +import { makeSQLKVStore } from './kernel-integration/sqlite-kv-store.js'; + main().catch(console.error); /** @@ -21,6 +23,7 @@ async function main(): Promise { new VatSupervisor({ id: 'iframe', commandStream, + makeKVStore: makeSQLKVStore, }); await multiplexer.start(); diff --git a/packages/extension/src/kernel-integration/kernel-worker.ts b/packages/extension/src/kernel-integration/kernel-worker.ts index 784734a94..28545d7ec 100644 --- a/packages/extension/src/kernel-integration/kernel-worker.ts +++ b/packages/extension/src/kernel-integration/kernel-worker.ts @@ -3,7 +3,7 @@ import type { KernelCommandReply, ClusterConfig, } from '@ocap/kernel'; -import { isKernelCommand, Kernel, makeSQLKVStore } from '@ocap/kernel'; +import { isKernelCommand, Kernel } from '@ocap/kernel'; import { MessagePortDuplexStream, receiveMessagePort, @@ -15,6 +15,7 @@ import { makeLogger } from '@ocap/utils'; import { handlePanelMessage } from './handle-panel-message.js'; import { isKernelControlCommand } from './messages.js'; import type { KernelControlCommand, KernelControlReply } from './messages.js'; +import { makeSQLKVStore } from './sqlite-kv-store.js'; import { ExtensionVatWorkerClient } from './VatWorkerClient.js'; const bundleHost = 'http://localhost:3000'; // XXX placeholder diff --git a/packages/kernel/src/store/sqlite-kv-store.ts b/packages/extension/src/kernel-integration/sqlite-kv-store.ts similarity index 94% rename from packages/kernel/src/store/sqlite-kv-store.ts rename to packages/extension/src/kernel-integration/sqlite-kv-store.ts index a055c24a7..176108685 100644 --- a/packages/kernel/src/store/sqlite-kv-store.ts +++ b/packages/extension/src/kernel-integration/sqlite-kv-store.ts @@ -1,17 +1,8 @@ +import type { KVStore } from '@ocap/kernel'; import { makeLogger } from '@ocap/utils'; import type { Database } from '@sqlite.org/sqlite-wasm'; import sqlite3InitModule from '@sqlite.org/sqlite-wasm'; -export type KVStore = { - get(key: string): string | undefined; - getRequired(key: string): string; - getNextKey(previousKey: string): string | undefined; - set(key: string, value: string): void; - delete(key: string): void; - clear(): void; - executeQuery(sql: string): Record[]; -}; - /** * Ensure that SQLite is initialized. * diff --git a/packages/kernel/package.json b/packages/kernel/package.json index 4fa0de43a..d9eed3839 100644 --- a/packages/kernel/package.json +++ b/packages/kernel/package.json @@ -59,7 +59,6 @@ "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", - "@sqlite.org/sqlite-wasm": "3.46.1-build3", "ses": "^1.9.0", "setimmediate": "^1.0.5" }, diff --git a/packages/kernel/src/Kernel.test.ts b/packages/kernel/src/Kernel.test.ts index cee9b10ad..4f093de63 100644 --- a/packages/kernel/src/Kernel.test.ts +++ b/packages/kernel/src/Kernel.test.ts @@ -13,7 +13,7 @@ import type { KernelCommandReply, VatCommand, } from './messages/index.js'; -import type { KVStore } from './store/sqlite-kv-store.js'; +import type { KVStore } from './store/kernel-store.js'; import type { VatId, VatConfig, VatWorkerService } from './types.js'; import { VatHandle } from './VatHandle.js'; import { makeMapKVStore } from '../test/storage.js'; diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 2d257d52f..52539e8db 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -29,13 +29,12 @@ import type { VatCommandReply, VatCommandReturnType, } from './messages/index.js'; -import type { KernelStore } from './store/kernel-store.js'; import { parseRef, isPromiseRef, makeKernelStore, } from './store/kernel-store.js'; -import type { KVStore } from './store/sqlite-kv-store.js'; +import type { KernelStore, KVStore } from './store/kernel-store.js'; import type { VatId, VRef, diff --git a/packages/kernel/src/VatSupervisor.test.ts b/packages/kernel/src/VatSupervisor.test.ts index f4c8740bd..72d233c14 100644 --- a/packages/kernel/src/VatSupervisor.test.ts +++ b/packages/kernel/src/VatSupervisor.test.ts @@ -31,6 +31,8 @@ const makeVatSupervisor = async ( supervisor: new VatSupervisor({ id: 'test-id', commandStream, + // @ts-expect-error Mock + makeKVStore: async () => ({}), }), stream, }; diff --git a/packages/kernel/src/VatSupervisor.ts b/packages/kernel/src/VatSupervisor.ts index b190edde2..38b9edf03 100644 --- a/packages/kernel/src/VatSupervisor.ts +++ b/packages/kernel/src/VatSupervisor.ts @@ -17,7 +17,7 @@ import type { import { makeDummyMeterControl } from './dummyMeterControl.js'; import type { VatCommand, VatCommandReply } from './messages/index.js'; import { VatCommandMethod } from './messages/index.js'; -import { makeSQLKVStore } from './store/sqlite-kv-store.js'; +import type { MakeKVStore } from './store/kernel-store.js'; import { makeSupervisorSyscall } from './syscall.js'; import type { VatConfig } from './types.js'; import { ROOT_OBJECT_VREF, isVatConfig } from './types.js'; @@ -32,6 +32,7 @@ const makeLiveSlots: (...args: unknown[]) => LiveSlots = localMakeLiveSlots; // type SupervisorConstructorProps = { id: string; commandStream: DuplexStream; + makeKVStore: MakeKVStore; }; const marshal = makeMarshal(undefined, undefined, { @@ -52,11 +53,14 @@ export class VatSupervisor { #dispatch: DispatchFn | null; + readonly #makeKVStore: MakeKVStore; + readonly #syscallsInFlight: Promise[] = []; - constructor({ id, commandStream }: SupervisorConstructorProps) { + constructor({ id, commandStream, makeKVStore }: SupervisorConstructorProps) { this.id = id; this.#commandStream = commandStream; + this.#makeKVStore = makeKVStore; this.#dispatch = null; Promise.all([ @@ -189,7 +193,7 @@ export class VatSupervisor { } this.#loaded = true; - const kvStore = await makeSQLKVStore(`[vat-${this.id}]`, true); + const kvStore = await this.#makeKVStore(`[vat-${this.id}]`, true); const syscall = makeSupervisorSyscall(this, kvStore); const vatPowers = {}; // XXX should be something more real const liveSlotsOptions = {}; // XXX should be something more real diff --git a/packages/kernel/src/index.test.ts b/packages/kernel/src/index.test.ts index d238a2a74..8311437c7 100644 --- a/packages/kernel/src/index.test.ts +++ b/packages/kernel/src/index.test.ts @@ -24,7 +24,6 @@ describe('index', () => { 'isVatId', 'isVatWorkerServiceCommand', 'isVatWorkerServiceReply', - 'makeSQLKVStore', ]); }); }); diff --git a/packages/kernel/src/index.ts b/packages/kernel/src/index.ts index ba8aacd6a..1ba543bb2 100644 --- a/packages/kernel/src/index.ts +++ b/packages/kernel/src/index.ts @@ -1,7 +1,6 @@ export * from './messages/index.js'; export { Kernel } from './Kernel.js'; -export type { KVStore } from './store/sqlite-kv-store.js'; -export { makeSQLKVStore } from './store/sqlite-kv-store.js'; +export type { KVStore, MakeKVStore } from './store/kernel-store.js'; export { VatHandle } from './VatHandle.js'; export { VatSupervisor } from './VatSupervisor.js'; // XXX Once the packaging of liveslots is fixed, this should be imported from there diff --git a/packages/kernel/src/store/kernel-store.test.ts b/packages/kernel/src/store/kernel-store.test.ts index c16196db2..b4c3441f9 100644 --- a/packages/kernel/src/store/kernel-store.test.ts +++ b/packages/kernel/src/store/kernel-store.test.ts @@ -1,7 +1,7 @@ import { describe, it, expect, beforeEach } from 'vitest'; import { makeKernelStore } from './kernel-store.js'; -import type { KVStore } from './sqlite-kv-store.js'; +import type { KVStore } from './kernel-store.js'; import { makeMapKVStore } from '../../test/storage.js'; // XXX Once the packaging of liveslots is fixed this should be imported from there import type { Message } from '../ag-types.js'; diff --git a/packages/kernel/src/store/kernel-store.ts b/packages/kernel/src/store/kernel-store.ts index aee9cd0ed..a92b42efc 100644 --- a/packages/kernel/src/store/kernel-store.ts +++ b/packages/kernel/src/store/kernel-store.ts @@ -55,7 +55,6 @@ import type { CapData } from '@endo/marshal'; -import type { KVStore } from './sqlite-kv-store.js'; // XXX Once the packaging of liveslots is fixed this should be imported from there import type { Message } from '../ag-types.js'; import type { @@ -69,6 +68,21 @@ import type { KernelPromise, } from '../types.js'; +export type KVStore = { + get(key: string): string | undefined; + getRequired(key: string): string; + getNextKey(previousKey: string): string | undefined; + set(key: string, value: string): void; + delete(key: string): void; + clear(): void; + executeQuery(sql: string): Record[]; +}; + +export type MakeKVStore = ( + label: string, + beEphemeral: boolean, +) => Promise; + type StoredValue = { get(): string | undefined; set(newValue: string): void; diff --git a/packages/kernel/src/syscall.ts b/packages/kernel/src/syscall.ts index 427d0fe31..913072eef 100644 --- a/packages/kernel/src/syscall.ts +++ b/packages/kernel/src/syscall.ts @@ -12,7 +12,7 @@ import type { VatOneResolution, SwingSetCapData, } from './ag-types-index.js'; -import type { KVStore } from './store/sqlite-kv-store.js'; +import type { KVStore } from './store/kernel-store.js'; import type { VatSupervisor } from './VatSupervisor.ts'; export type SyscallResult = SwingSetCapData | string | string[] | null; diff --git a/packages/kernel/test/storage.ts b/packages/kernel/test/storage.ts index 246f56138..15cd00e9e 100644 --- a/packages/kernel/test/storage.ts +++ b/packages/kernel/test/storage.ts @@ -1,4 +1,4 @@ -import type { KVStore } from '../src/store/sqlite-kv-store.js'; +import type { KVStore } from '../src/store/kernel-store.js'; /** * A mock key/value store realized as a Map. diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index efde1bad6..313090c40 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -6,6 +6,8 @@ import { NodeWorkerMultiplexer } from '@ocap/streams'; import { makeLogger } from '@ocap/utils'; import { parentPort } from 'node:worker_threads'; +import { makeSQLKVStore } from '../kernel/sqlite-kv-store.js'; + // eslint-disable-next-line n/no-process-env const logger = makeLogger(`[vat-worker (${process.env.NODE_VAT_ID})]`); @@ -29,5 +31,6 @@ async function main(): Promise { void new VatSupervisor({ id: 'iframe', commandStream, + makeKVStore: makeSQLKVStore, }); } diff --git a/vitest.config.ts b/vitest.config.ts index 97dabb886..2dfb2f545 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -61,16 +61,16 @@ export default defineConfig({ lines: 100, }, 'packages/extension/**': { - statements: 74.89, - functions: 74.7, - branches: 78.62, - lines: 74.79, + statements: 66.48, + functions: 70.55, + branches: 69.12, + lines: 66.48, }, 'packages/kernel/**': { - statements: 39.05, - functions: 50.31, - branches: 28.17, - lines: 39.33, + statements: 42.2, + functions: 53.69, + branches: 30.03, + lines: 42.47, }, 'packages/nodejs/**': { statements: 4.12, diff --git a/yarn.lock b/yarn.lock index 5173b3e73..d29819940 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2108,6 +2108,7 @@ __metadata: "@ocap/test-utils": "workspace:^" "@ocap/utils": "workspace:^" "@playwright/test": "npm:^1.49.1" + "@sqlite.org/sqlite-wasm": "npm:^3.48.0-build1" "@testing-library/jest-dom": "npm:^6.6.3" "@testing-library/react": "npm:^16.1.0" "@testing-library/user-event": "npm:^14.5.2" @@ -2173,7 +2174,6 @@ __metadata: "@ocap/streams": "workspace:^" "@ocap/test-utils": "workspace:^" "@ocap/utils": "workspace:^" - "@sqlite.org/sqlite-wasm": "npm:3.46.1-build3" "@ts-bridge/cli": "npm:^0.6.2" "@ts-bridge/shims": "npm:^0.1.1" "@types/setimmediate": "npm:^1.0.4" @@ -3013,12 +3013,12 @@ __metadata: languageName: node linkType: hard -"@sqlite.org/sqlite-wasm@npm:3.46.1-build3": - version: 3.46.1-build3 - resolution: "@sqlite.org/sqlite-wasm@npm:3.46.1-build3" +"@sqlite.org/sqlite-wasm@npm:^3.48.0-build1": + version: 3.48.0-build1 + resolution: "@sqlite.org/sqlite-wasm@npm:3.48.0-build1" bin: sqlite-wasm: bin/index.js - checksum: 10/a64225fd784ed2ee8c8bf82f042d05b567b4707fba22a9508fbe3ac42cf1cf7e722d2ede0e1d91556bfec66b140aeb3cf3967546249693f39cc81475d7be90ff + checksum: 10/e163ac23f79176ca777db285dd19384b52feac64725bcfef24ec925a0e6f1f0b80acfbcc238656cd695b096e95cf63f38d4f0c05178367cfa5c6a75bd9aeb35c languageName: node linkType: hard From 01026803df7a2819c919bcfd18126758db1c60a3 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 9 Jan 2025 14:55:13 -0600 Subject: [PATCH 02/55] draft --- packages/nodejs/src/vat/inside.test.ts | 66 ++++++++++++++++++++++++++ packages/nodejs/src/vat/vat-worker.ts | 2 + 2 files changed, 68 insertions(+) create mode 100644 packages/nodejs/src/vat/inside.test.ts diff --git a/packages/nodejs/src/vat/inside.test.ts b/packages/nodejs/src/vat/inside.test.ts new file mode 100644 index 000000000..cd4f60cbe --- /dev/null +++ b/packages/nodejs/src/vat/inside.test.ts @@ -0,0 +1,66 @@ +import '@ocap/shims/endoify'; + +import { VatSupervisor } from '@ocap/kernel'; +import { NodeWorkerMultiplexer } from '@ocap/streams'; +import { makeLogger } from '@ocap/utils'; +import { describe, expect, it, vi } from 'vitest'; + +import { main } from './inside.js'; + +vi.mock('node:worker_threads', () => ({ + parentPort: {}, +})); + +vi.mock('@ocap/kernel', () => { + const MockVatSupervisor = vi.fn(); + vi.spyOn(MockVatSupervisor.prototype, 'evaluate').mockImplementation(); + return { + VatSupervisor: MockVatSupervisor, + }; +}); + +vi.mock('@ocap/streams', () => { + const MockNodeWorkerMultiplexer = vi.fn(); + vi.spyOn(MockNodeWorkerMultiplexer.prototype, 'start') + .mockImplementation() + .mockResolvedValue(undefined); + vi.spyOn( + MockNodeWorkerMultiplexer.prototype, + 'createChannel', + ).mockImplementation(); + + return { + NodeWorkerMultiplexer: MockNodeWorkerMultiplexer, + }; +}); + +describe('inside', () => { + it('reads vat id from NODE_VAT_ID', async () => { + const vatId = 'v20'; + vi.stubEnv('NODE_VAT_ID', vatId); + await main(); + expect(makeLogger).toHaveBeenCalledWith(`[${vatId} (inside)]`); + }); + + it('creates a VatSupervisor and call its evaluate method', async () => { + const MockNodeWorkerMultiplexer = vi.mocked(NodeWorkerMultiplexer); + const MockVatSupervisor = vi.mocked(VatSupervisor); + + await main(); + + expect(MockNodeWorkerMultiplexer).toHaveBeenCalledOnce(); + expect(MockNodeWorkerMultiplexer.mock.instances.at(0)).toBeDefined(); + expect( + MockNodeWorkerMultiplexer.mock.instances.at(0)?.start, + ).toHaveBeenCalledOnce(); + expect( + MockNodeWorkerMultiplexer.mock.instances.at(0)?.createChannel, + ).toHaveBeenCalledTimes(2); + + expect(MockVatSupervisor).toHaveBeenCalledOnce(); + expect(MockVatSupervisor.mock.instances.at(0)).toBeDefined(); + expect( + MockVatSupervisor.mock.instances.at(0)?.evaluate, + ).toHaveBeenCalledWith('["Hello", "world!"].join(" ");'); + }); +}); diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 313090c40..f3ef3e919 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -23,7 +23,9 @@ async function main(): Promise { throw new Error(errMsg); } const multiplexer = new NodeWorkerMultiplexer(parentPort, 'vat'); + console.debug('premulti'); multiplexer.start().catch(logger.error); + console.debug('postmulti'); const commandStream = multiplexer.createChannel( 'command', ); From f55c9ce51f972c7138fb0c44c2d922de72cec7e6 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 10 Jan 2025 13:49:41 -0600 Subject: [PATCH 03/55] fix vitest endoify resolution --- packages/nodejs/vitest.config.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/nodejs/vitest.config.ts b/packages/nodejs/vitest.config.ts index 7e149b0e5..e460f88d4 100644 --- a/packages/nodejs/vitest.config.ts +++ b/packages/nodejs/vitest.config.ts @@ -13,7 +13,7 @@ const config = mergeConfig( alias: [ { find: '@ocap/shims/endoify', - replacement: path.resolve('../shims/src/endoify.js'), + replacement: path.resolve(__dirname, '../shims/src/endoify.js'), customResolver: (id) => ({ external: true, id }), }, ], From 6df657b376b16b324c305669baafa3b09bf2f842 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 10 Jan 2025 18:24:54 -0600 Subject: [PATCH 04/55] align nodejs vat-worker with extension vat iframe --- packages/nodejs/src/vat/inside.test.ts | 66 ---------------------- packages/nodejs/src/vat/vat-worker.test.ts | 59 +++++++++++++++++++ packages/nodejs/src/vat/vat-worker.ts | 16 +++--- 3 files changed, 68 insertions(+), 73 deletions(-) delete mode 100644 packages/nodejs/src/vat/inside.test.ts create mode 100644 packages/nodejs/src/vat/vat-worker.test.ts diff --git a/packages/nodejs/src/vat/inside.test.ts b/packages/nodejs/src/vat/inside.test.ts deleted file mode 100644 index cd4f60cbe..000000000 --- a/packages/nodejs/src/vat/inside.test.ts +++ /dev/null @@ -1,66 +0,0 @@ -import '@ocap/shims/endoify'; - -import { VatSupervisor } from '@ocap/kernel'; -import { NodeWorkerMultiplexer } from '@ocap/streams'; -import { makeLogger } from '@ocap/utils'; -import { describe, expect, it, vi } from 'vitest'; - -import { main } from './inside.js'; - -vi.mock('node:worker_threads', () => ({ - parentPort: {}, -})); - -vi.mock('@ocap/kernel', () => { - const MockVatSupervisor = vi.fn(); - vi.spyOn(MockVatSupervisor.prototype, 'evaluate').mockImplementation(); - return { - VatSupervisor: MockVatSupervisor, - }; -}); - -vi.mock('@ocap/streams', () => { - const MockNodeWorkerMultiplexer = vi.fn(); - vi.spyOn(MockNodeWorkerMultiplexer.prototype, 'start') - .mockImplementation() - .mockResolvedValue(undefined); - vi.spyOn( - MockNodeWorkerMultiplexer.prototype, - 'createChannel', - ).mockImplementation(); - - return { - NodeWorkerMultiplexer: MockNodeWorkerMultiplexer, - }; -}); - -describe('inside', () => { - it('reads vat id from NODE_VAT_ID', async () => { - const vatId = 'v20'; - vi.stubEnv('NODE_VAT_ID', vatId); - await main(); - expect(makeLogger).toHaveBeenCalledWith(`[${vatId} (inside)]`); - }); - - it('creates a VatSupervisor and call its evaluate method', async () => { - const MockNodeWorkerMultiplexer = vi.mocked(NodeWorkerMultiplexer); - const MockVatSupervisor = vi.mocked(VatSupervisor); - - await main(); - - expect(MockNodeWorkerMultiplexer).toHaveBeenCalledOnce(); - expect(MockNodeWorkerMultiplexer.mock.instances.at(0)).toBeDefined(); - expect( - MockNodeWorkerMultiplexer.mock.instances.at(0)?.start, - ).toHaveBeenCalledOnce(); - expect( - MockNodeWorkerMultiplexer.mock.instances.at(0)?.createChannel, - ).toHaveBeenCalledTimes(2); - - expect(MockVatSupervisor).toHaveBeenCalledOnce(); - expect(MockVatSupervisor.mock.instances.at(0)).toBeDefined(); - expect( - MockVatSupervisor.mock.instances.at(0)?.evaluate, - ).toHaveBeenCalledWith('["Hello", "world!"].join(" ");'); - }); -}); diff --git a/packages/nodejs/src/vat/vat-worker.test.ts b/packages/nodejs/src/vat/vat-worker.test.ts new file mode 100644 index 000000000..f96d15fa5 --- /dev/null +++ b/packages/nodejs/src/vat/vat-worker.test.ts @@ -0,0 +1,59 @@ +import '@ocap/shims/endoify'; + +import * as ocapKernel from '@ocap/kernel'; +import * as ocapStreams from '@ocap/streams'; +import * as ocapUtils from '@ocap/utils'; +import { describe, expect, it, vi } from 'vitest'; + +import { main } from './vat-worker.js'; + +vi.mock('node:worker_threads', () => ({ + parentPort: '{- parentPort -}', +})); + +vi.mock('@ocap/kernel', async (importOriginal: () => Promise) => { + const actual = await importOriginal(); + return { + ...actual, + VatSupervisor: vi.fn(() => ({ + evaluate: vi.fn(), + })), + } +}); + +vi.mock('@ocap/streams', () => ({ + NodeWorkerMultiplexer: vi.fn(() => ({ + start: vi.fn().mockRejectedValue(undefined), + createChannel: vi.fn(), + })), +})); + +describe('inside', () => { + it('creates a VatSupervisor and call its evaluate method', async () => { + const spyNodeWorkerMultiplexer = vi.spyOn(ocapStreams, 'NodeWorkerMultiplexer'); + const spyVatSupervisor = vi.spyOn(ocapKernel, 'VatSupervisor'); + + const vatId = 'v20'; + vi.stubEnv('NODE_VAT_ID', vatId); + + await main(); + + expect(spyNodeWorkerMultiplexer).toHaveBeenCalledOnce(); + expect(spyNodeWorkerMultiplexer.mock.instances.at(0)).toBeDefined(); + expect( + spyNodeWorkerMultiplexer.mock.instances.at(0)?.start, + ).toHaveBeenCalledOnce(); + expect( + spyNodeWorkerMultiplexer.mock.instances.at(0)?.createChannel, + ).toHaveBeenCalledTimes(2); + + expect(spyVatSupervisor).toHaveBeenCalledOnce(); + expect(spyVatSupervisor).toHaveBeenCalledWith({ + id: vatId, + }); + expect(spyVatSupervisor.mock.instances.at(0)).toBeDefined(); + expect( + spyVatSupervisor.mock.instances.at(0)?.evaluate, + ).toHaveBeenCalledWith('["Hello", "world!"].join(" ");'); + }); +}); diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index f3ef3e919..b43bc42bb 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -1,36 +1,38 @@ import '@ocap/shims/endoify'; -import { VatSupervisor } from '@ocap/kernel'; +import { isVatCommand, VatSupervisor } from '@ocap/kernel'; import type { VatCommand, VatCommandReply } from '@ocap/kernel'; import { NodeWorkerMultiplexer } from '@ocap/streams'; import { makeLogger } from '@ocap/utils'; import { parentPort } from 'node:worker_threads'; import { makeSQLKVStore } from '../kernel/sqlite-kv-store.js'; +const vatId = process.env.NODE_VAT_ID // eslint-disable-next-line n/no-process-env -const logger = makeLogger(`[vat-worker (${process.env.NODE_VAT_ID})]`); +const logger = makeLogger(`[vat-worker ${vatId}]`); main().catch(logger.error); /** * The main function for the iframe. */ -async function main(): Promise { +export async function main(): Promise { + logger.debug('started main'); + if (!parentPort) { const errMsg = 'Expected to run in Node Worker with parentPort.'; logger.error(errMsg); throw new Error(errMsg); } const multiplexer = new NodeWorkerMultiplexer(parentPort, 'vat'); - console.debug('premulti'); multiplexer.start().catch(logger.error); - console.debug('postmulti'); const commandStream = multiplexer.createChannel( 'command', + isVatCommand, ); - // eslint-disable-next-line no-void - void new VatSupervisor({ + + const supervisor = new VatSupervisor({ id: 'iframe', commandStream, makeKVStore: makeSQLKVStore, From 9f034bbc8d6d00cc802adeb0501c8bd506a54122 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 14 Jan 2025 12:04:03 -0600 Subject: [PATCH 05/55] draft --- eslint.config.mjs | 8 +++ packages/nodejs/package.json | 2 +- packages/nodejs/src/vat-worker.ts | 25 +++++++ .../nodejs/src/vat/make-multiplexer.test.ts | 43 ++++++++++++ packages/nodejs/src/vat/make-multiplexer.ts | 28 ++++++++ .../nodejs/src/vat/make-vat-worker.test.ts | 67 +++++++++++++++++++ packages/nodejs/src/vat/make-vat-worker.ts | 47 +++++++++++++ packages/nodejs/src/vat/vat-worker.test.ts | 59 ---------------- packages/nodejs/src/vat/vat-worker.ts | 40 ----------- 9 files changed, 219 insertions(+), 100 deletions(-) create mode 100644 packages/nodejs/src/vat-worker.ts create mode 100644 packages/nodejs/src/vat/make-multiplexer.test.ts create mode 100644 packages/nodejs/src/vat/make-multiplexer.ts create mode 100644 packages/nodejs/src/vat/make-vat-worker.test.ts create mode 100644 packages/nodejs/src/vat/make-vat-worker.ts delete mode 100644 packages/nodejs/src/vat/vat-worker.test.ts delete mode 100644 packages/nodejs/src/vat/vat-worker.ts diff --git a/eslint.config.mjs b/eslint.config.mjs index 21a89f057..4e7bbc754 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -179,6 +179,14 @@ const config = createConfig([ globals: { lockdown: 'readonly' }, }, }, + + { + files: ['packages/nodejs/**/*-worker.ts'], + rules: { + // Node workers have reasonable cause to read from process.env + 'n/no-process-env': 'off', + }, + }, ]); export default config; diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 443ee59aa..e72432af5 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -34,7 +34,7 @@ "publish:preview": "yarn npm publish --tag preview", "test": "vitest run --config vitest.config.ts", "test:e2e": "vitest run --config vitest.config.e2e.ts", - "test:e2e:ci": "echo 'skipped tests' || ./scripts/test-e2e-ci.sh", + "test:e2e:ci": "./scripts/test-e2e-ci.sh", "test:clean": "yarn test --no-cache --coverage.clean", "test:dev": "yarn test --coverage false", "test:verbose": "yarn test --reporter verbose", diff --git a/packages/nodejs/src/vat-worker.ts b/packages/nodejs/src/vat-worker.ts new file mode 100644 index 000000000..b38aaac6f --- /dev/null +++ b/packages/nodejs/src/vat-worker.ts @@ -0,0 +1,25 @@ +import '@ocap/shims/endoify'; + +import type { VatId } from '@ocap/kernel'; +import { makeLogger } from '@ocap/utils'; + +import { makeSQLKVStore } from './kernel/sqlite-kv-store.js'; +import { makeMultiplexer } from './vat/make-multiplexer.js'; +import { makeVatWorker } from './vat/make-vat-worker.js'; + +const vatId = process.env.NODE_VAT_ID as VatId; + +if (vatId) { + const logger = makeLogger(`[vat-worker (${vatId})]`); + logger.debug('starting worker...'); + const { start, stop } = makeVatWorker(vatId, makeMultiplexer, makeSQLKVStore); + try { + await start(); + } catch (problem) { + logger.error(problem); + } finally { + await stop(); + } +} else { + console.log('no vatId set for env variable NODE_VAT_ID'); +} diff --git a/packages/nodejs/src/vat/make-multiplexer.test.ts b/packages/nodejs/src/vat/make-multiplexer.test.ts new file mode 100644 index 000000000..640c030b7 --- /dev/null +++ b/packages/nodejs/src/vat/make-multiplexer.test.ts @@ -0,0 +1,43 @@ +import '@ocap/shims/endoify'; + +import { describe, expect, it, vi } from 'vitest'; + +describe('getPort', () => { + it('returns a port', async () => { + const mockParentPort = {}; + vi.doMock('node:worker_threads', () => ({ + parentPort: mockParentPort, + })); + vi.resetModules(); + + const { getPort } = await import('./make-multiplexer.js'); + + const port = getPort(); + + expect(port).toStrictEqual(mockParentPort); + }); + + it('throws if parentPort is not defined', async () => { + vi.doMock('node:worker_threads', () => ({ + parentPort: undefined, + })); + vi.resetModules(); + + const { getPort } = await import('./make-multiplexer.js'); + + expect(getPort).toThrow(/parentPort/u); + }); +}); + +describe('makeMultiplexer', () => { + it('returns a NodeWorkerMultiplexer', async () => { + vi.doMock('node:worker_threads', () => ({ + parentPort: new MessageChannel().port1, + })); + vi.resetModules(); + const { NodeWorkerMultiplexer } = await import('@ocap/streams'); + const { makeMultiplexer } = await import('./make-multiplexer.js'); + const multiplexer = makeMultiplexer('v0'); + expect(multiplexer).toBeInstanceOf(NodeWorkerMultiplexer); + }); +}); diff --git a/packages/nodejs/src/vat/make-multiplexer.ts b/packages/nodejs/src/vat/make-multiplexer.ts new file mode 100644 index 000000000..c75d3f007 --- /dev/null +++ b/packages/nodejs/src/vat/make-multiplexer.ts @@ -0,0 +1,28 @@ +import { NodeWorkerMultiplexer } from '@ocap/streams'; +import { parentPort } from 'node:worker_threads'; + +/** + * Return the parent port of the Node.js worker if it exists; otherwise throw. + * + * @returns The parent port. + * @throws If not called from within a Node.js worker. + */ +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +export function getPort() { + if (!parentPort) { + const errMsg = 'Expected to run in Node Worker with parentPort.'; + throw new Error(errMsg); + } + return parentPort; +} + +/** + * When called from within Node.js worker, returns a Multiplexer which + * communicates over the parentPort. + * + * @param name - The name to give this multiplexer (for traffic logging). + * @returns A NodeWorkerMultiplexer + */ +export function makeMultiplexer(name?: string): NodeWorkerMultiplexer { + return new NodeWorkerMultiplexer(getPort(), name); +} diff --git a/packages/nodejs/src/vat/make-vat-worker.test.ts b/packages/nodejs/src/vat/make-vat-worker.test.ts new file mode 100644 index 000000000..ad6063728 --- /dev/null +++ b/packages/nodejs/src/vat/make-vat-worker.test.ts @@ -0,0 +1,67 @@ +import '@ocap/shims/endoify'; + +import { beforeEach, describe, expect, it, vi } from 'vitest'; + +import { makeMultiplexer } from './make-multiplexer.js'; +import { makeVatWorker as makeVatWorkerDecl } from './make-vat-worker.js'; + +type MakeVatWorker = typeof makeVatWorkerDecl; + +describe('makeVatWorker', () => { + const testVatId = 'v0'; + let makeVatWorker: MakeVatWorker; + let mockMakeMultiplexer: typeof makeMultiplexer; + + beforeEach(async () => { + mockMakeMultiplexer = vi.fn().mockImplementation(() => ({ + start: vi.fn().mockResolvedValue(undefined), + return: vi.fn().mockResolvedValue(undefined), + createChannel: vi.fn(), + })); + vi.doMock('@ocap/streams', () => ({ + NodeWorkerMultiplexer: vi.fn(), + })); + vi.doMock('@ocap/kernel', () => ({ + VatSupervisor: vi.fn().mockImplementation(() => ({ + terminate: vi.fn().mockResolvedValue(undefined), + })), + isVatCommand: vi.fn(), + })); + vi.resetModules(); + makeVatWorker = (await import('./make-vat-worker.js')).makeVatWorker; + }); + + it('returns an object with start and stop methods', async () => { + const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); + + expect(vatWorker).toHaveProperty('start'); + expect(vatWorker).toHaveProperty('stop'); + }); + + describe('start', () => { + it('starts the multiplexer', async () => { + const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); + + await vatWorker.start(); + + expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); + expect( + mockMakeMultiplexer.mock.results.at(0).value.start, + ).toHaveBeenCalledOnce(); + }); + }); + + describe('stop', () => { + it('calls supervisor.terminate and multiplexer.return', async () => { + const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); + + await vatWorker.start(); + await vatWorker.stop(); + + expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); + expect( + mockMakeMultiplexer.mock.results.at(0).value.return, + ).toHaveBeenCalledOnce(); + }); + }); +}); diff --git a/packages/nodejs/src/vat/make-vat-worker.ts b/packages/nodejs/src/vat/make-vat-worker.ts new file mode 100644 index 000000000..7260ceddc --- /dev/null +++ b/packages/nodejs/src/vat/make-vat-worker.ts @@ -0,0 +1,47 @@ +import { isVatCommand, VatSupervisor } from '@ocap/kernel'; +import type { + MakeKVStore, + VatCommand, + VatCommandReply, + VatId, +} from '@ocap/kernel'; +import type { StreamMultiplexer } from '@ocap/streams'; + +/** + * Assemble a vat worker for the target environment. + * + * @param vatId - The id of the vat inside the worker. + * @param makeMultiplexer - A routine to make a Multiplexer for the VatSupervisor. + * @param makeKVStore - A routine to make a KVStore for the VatSupervisor. + * @returns A vat worker object with awaitable start and stop methods. + */ +export function makeVatWorker( + vatId: VatId, + makeMultiplexer: (name?: string) => StreamMultiplexer, + makeKVStore: MakeKVStore, +): { + start: () => Promise; + stop: () => Promise; +} { + const multiplexer = makeMultiplexer(vatId); + const commandStream = multiplexer.createChannel( + 'command', + isVatCommand, + ); + + const supervisor = new VatSupervisor({ + id: `S${vatId}`, + commandStream, + makeKVStore, + }); + + return { + start: async () => { + await multiplexer.start(); + }, + stop: async () => { + await supervisor.terminate(); + await multiplexer.return(); + }, + }; +} diff --git a/packages/nodejs/src/vat/vat-worker.test.ts b/packages/nodejs/src/vat/vat-worker.test.ts deleted file mode 100644 index f96d15fa5..000000000 --- a/packages/nodejs/src/vat/vat-worker.test.ts +++ /dev/null @@ -1,59 +0,0 @@ -import '@ocap/shims/endoify'; - -import * as ocapKernel from '@ocap/kernel'; -import * as ocapStreams from '@ocap/streams'; -import * as ocapUtils from '@ocap/utils'; -import { describe, expect, it, vi } from 'vitest'; - -import { main } from './vat-worker.js'; - -vi.mock('node:worker_threads', () => ({ - parentPort: '{- parentPort -}', -})); - -vi.mock('@ocap/kernel', async (importOriginal: () => Promise) => { - const actual = await importOriginal(); - return { - ...actual, - VatSupervisor: vi.fn(() => ({ - evaluate: vi.fn(), - })), - } -}); - -vi.mock('@ocap/streams', () => ({ - NodeWorkerMultiplexer: vi.fn(() => ({ - start: vi.fn().mockRejectedValue(undefined), - createChannel: vi.fn(), - })), -})); - -describe('inside', () => { - it('creates a VatSupervisor and call its evaluate method', async () => { - const spyNodeWorkerMultiplexer = vi.spyOn(ocapStreams, 'NodeWorkerMultiplexer'); - const spyVatSupervisor = vi.spyOn(ocapKernel, 'VatSupervisor'); - - const vatId = 'v20'; - vi.stubEnv('NODE_VAT_ID', vatId); - - await main(); - - expect(spyNodeWorkerMultiplexer).toHaveBeenCalledOnce(); - expect(spyNodeWorkerMultiplexer.mock.instances.at(0)).toBeDefined(); - expect( - spyNodeWorkerMultiplexer.mock.instances.at(0)?.start, - ).toHaveBeenCalledOnce(); - expect( - spyNodeWorkerMultiplexer.mock.instances.at(0)?.createChannel, - ).toHaveBeenCalledTimes(2); - - expect(spyVatSupervisor).toHaveBeenCalledOnce(); - expect(spyVatSupervisor).toHaveBeenCalledWith({ - id: vatId, - }); - expect(spyVatSupervisor.mock.instances.at(0)).toBeDefined(); - expect( - spyVatSupervisor.mock.instances.at(0)?.evaluate, - ).toHaveBeenCalledWith('["Hello", "world!"].join(" ");'); - }); -}); diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts deleted file mode 100644 index b43bc42bb..000000000 --- a/packages/nodejs/src/vat/vat-worker.ts +++ /dev/null @@ -1,40 +0,0 @@ -import '@ocap/shims/endoify'; - -import { isVatCommand, VatSupervisor } from '@ocap/kernel'; -import type { VatCommand, VatCommandReply } from '@ocap/kernel'; -import { NodeWorkerMultiplexer } from '@ocap/streams'; -import { makeLogger } from '@ocap/utils'; -import { parentPort } from 'node:worker_threads'; - -import { makeSQLKVStore } from '../kernel/sqlite-kv-store.js'; -const vatId = process.env.NODE_VAT_ID - -// eslint-disable-next-line n/no-process-env -const logger = makeLogger(`[vat-worker ${vatId}]`); - -main().catch(logger.error); - -/** - * The main function for the iframe. - */ -export async function main(): Promise { - logger.debug('started main'); - - if (!parentPort) { - const errMsg = 'Expected to run in Node Worker with parentPort.'; - logger.error(errMsg); - throw new Error(errMsg); - } - const multiplexer = new NodeWorkerMultiplexer(parentPort, 'vat'); - multiplexer.start().catch(logger.error); - const commandStream = multiplexer.createChannel( - 'command', - isVatCommand, - ); - - const supervisor = new VatSupervisor({ - id: 'iframe', - commandStream, - makeKVStore: makeSQLKVStore, - }); -} From 13e860ce53467df8603fedb98ba72d074bcb4730 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 22 Jan 2025 02:50:54 -0600 Subject: [PATCH 06/55] XtrEme uNiT tESTing --- eslint.config.mjs | 5 +- package.json | 1 + packages/nodejs/package.json | 2 +- .../src/kernel/VatWorkerService.test.ts | 64 ++++++++++ .../nodejs/src/kernel/VatWorkerService.ts | 14 ++- packages/nodejs/src/kernel/kernel-worker.ts | 87 ------------- .../nodejs/src/kernel/make-kernel.test.ts | 24 ++++ packages/nodejs/src/kernel/make-kernel.ts | 34 +++++ packages/nodejs/src/vat-worker.ts | 25 ---- .../nodejs/src/vat/make-multiplexer.test.ts | 63 ++++++---- packages/nodejs/src/vat/make-multiplexer.ts | 6 +- .../nodejs/src/vat/make-vat-worker.test.ts | 67 +++++----- packages/nodejs/src/vat/make-vat-worker.ts | 22 +--- packages/nodejs/src/vat/vat-worker.ts | 19 +++ .../nodejs/test/e2e/kernel-worker.test.ts | 118 +++++++++++++++++- packages/nodejs/test/workers/hello-world.mjs | 3 + packages/nodejs/test/workers/index.ts | 2 + packages/nodejs/test/workers/ping-pong.mjs | 13 ++ vitest.config.ts | 10 +- 19 files changed, 368 insertions(+), 211 deletions(-) delete mode 100644 packages/nodejs/src/kernel/kernel-worker.ts create mode 100644 packages/nodejs/src/kernel/make-kernel.test.ts create mode 100644 packages/nodejs/src/kernel/make-kernel.ts delete mode 100644 packages/nodejs/src/vat-worker.ts create mode 100644 packages/nodejs/src/vat/vat-worker.ts create mode 100644 packages/nodejs/test/workers/hello-world.mjs create mode 100644 packages/nodejs/test/workers/index.ts create mode 100644 packages/nodejs/test/workers/ping-pong.mjs diff --git a/eslint.config.mjs b/eslint.config.mjs index 4e7bbc754..ebddd69cf 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -181,7 +181,10 @@ const config = createConfig([ }, { - files: ['packages/nodejs/**/*-worker.ts'], + files: [ + 'packages/nodejs/**/*-worker.ts', + 'packages/nodejs/test/workers/**/*.mjs', + ], rules: { // Node workers have reasonable cause to read from process.env 'n/no-process-env': 'off', diff --git a/package.json b/package.json index 0850a26b5..559e8baf3 100644 --- a/package.json +++ b/package.json @@ -34,6 +34,7 @@ "test": "vitest run", "test:clean": "yarn test --no-cache --coverage.clean", "test:dev": "yarn test --coverage false", + "test:e2e": "yarn workspaces foreach --all run test:e2e", "test:e2e:ci": "yarn workspaces foreach --all run test:e2e:ci", "test:verbose": "yarn test --reporter verbose", "test:watch": "vitest", diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index e72432af5..443ee59aa 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -34,7 +34,7 @@ "publish:preview": "yarn npm publish --tag preview", "test": "vitest run --config vitest.config.ts", "test:e2e": "vitest run --config vitest.config.e2e.ts", - "test:e2e:ci": "./scripts/test-e2e-ci.sh", + "test:e2e:ci": "echo 'skipped tests' || ./scripts/test-e2e-ci.sh", "test:clean": "yarn test --no-cache --coverage.clean", "test:dev": "yarn test --coverage false", "test:verbose": "yarn test --reporter verbose", diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index d665cecfb..e26bf3c08 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -1,12 +1,76 @@ import '@ocap/shims/endoify'; +import type { VatId } from '@ocap/kernel'; +import { NodeWorkerMultiplexer } from '@ocap/streams'; +import { makeCounter } from '@ocap/utils'; import { describe, expect, it } from 'vitest'; import { NodejsVatWorkerService } from './VatWorkerService.js'; +import { getTestWorkerFile } from '../../test/workers'; describe('NodejsVatWorkerService', () => { it('constructs an instance without any arguments', () => { const instance = new NodejsVatWorkerService(); expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); + + const vatIdCounter = makeCounter(); + const getTestVatId = (): VatId => `v${vatIdCounter()}`; + + describe('launch', () => { + it('creates a NodeWorker and returns a NodeWorkerMultiplexer', async () => { + const service = new NodejsVatWorkerService( + getTestWorkerFile('hello-world'), + ); + const testVatId: VatId = getTestVatId(); + const multiplexer = await service.launch(testVatId); + + expect(multiplexer).toBeInstanceOf(NodeWorkerMultiplexer); + }); + }); + + describe('terminate', () => { + it('terminates the target vat', async () => { + const service = new NodejsVatWorkerService( + getTestWorkerFile('hello-world'), + ); + const testVatId: VatId = getTestVatId(); + + await service.launch(testVatId); + expect(service.workers.has(testVatId)).toBe(true); + + await service.terminate(testVatId); + expect(service.workers.has(testVatId)).toBe(false); + }); + + it('throws when terminating an unknown vat', async () => { + const service = new NodejsVatWorkerService( + getTestWorkerFile('hello-world'), + ); + const testVatId: VatId = getTestVatId(); + + await expect( + async () => await service.terminate(testVatId), + ).rejects.toThrow(/No worker found/u); + }); + }); + + describe('terminateAll', () => { + it('terminates all vats', async () => { + const service = new NodejsVatWorkerService( + getTestWorkerFile('hello-world'), + ); + const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; + + await Promise.all( + vatIds.map(async (vatId) => await service.launch(vatId)), + ); + + expect(Array.from(service.workers.values())).toHaveLength(vatIds.length); + + await service.terminateAll(); + + expect(Array.from(service.workers.values())).toHaveLength(0); + }); + }); }); diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 4692ebb9b..42c8d860e 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -7,12 +7,16 @@ import { Worker as NodeWorker } from 'node:worker_threads'; // Worker file loads from the built dist directory, requires rebuild after change // Note: Worker runs in same process and may be subject to spectre-style attacks -const workerFileURL = new URL('../../dist/vat/vat-worker.mjs', import.meta.url) - .pathname; +const DEFAULT_WORKER_FILE = new URL( + '../../dist/vat/vat-worker.mjs', + import.meta.url, +).pathname; export class NodejsVatWorkerService implements VatWorkerService { readonly #logger: Logger; + readonly #workerFilePath: string; + workers = new Map< VatId, { worker: NodeWorker; multiplexer: StreamMultiplexer } @@ -22,16 +26,18 @@ export class NodejsVatWorkerService implements VatWorkerService { * The vat worker service, intended to be constructed in * the kernel worker. * + * @param workerFilePath - The path to a file defining the worker's routine. * @param logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'. */ - constructor(logger?: Logger) { + constructor(workerFilePath: string = DEFAULT_WORKER_FILE, logger?: Logger) { + this.#workerFilePath = workerFilePath; this.#logger = logger ?? makeLogger('[vat worker service]'); } async launch(vatId: VatId): Promise { const { promise, resolve } = makePromiseKit(); this.#logger.debug('launching', vatId); - const worker = new NodeWorker(workerFileURL, { + const worker = new NodeWorker(this.#workerFilePath, { env: { NODE_VAT_ID: vatId, }, diff --git a/packages/nodejs/src/kernel/kernel-worker.ts b/packages/nodejs/src/kernel/kernel-worker.ts deleted file mode 100644 index 302bcb80f..000000000 --- a/packages/nodejs/src/kernel/kernel-worker.ts +++ /dev/null @@ -1,87 +0,0 @@ -import '@ocap/shims/endoify'; -import type { NonEmptyArray } from '@metamask/utils'; -import type { KernelCommand, KernelCommandReply, VatId } from '@ocap/kernel'; -import { Kernel, VatCommandMethod } from '@ocap/kernel'; -import { NodeWorkerDuplexStream } from '@ocap/streams'; -import { MessagePort as NodeMessagePort } from 'worker_threads'; - -import { makeSQLKVStore } from './sqlite-kv-store.js'; -import { NodejsVatWorkerService } from './VatWorkerService.js'; - -/** - * The main function for the kernel worker. - * - * @param port - The kernel's end of a node:worker_threads MessageChannel - * @returns The kernel, initialized. - */ -export async function makeKernel(port: NodeMessagePort): Promise { - const nodeStream = new NodeWorkerDuplexStream< - KernelCommand, - KernelCommandReply - >(port); - const vatWorkerClient = new NodejsVatWorkerService(); - - // Initialize kernel store. - const kvStore = await makeSQLKVStore(); - - // Create and start kernel. - const kernel = new Kernel(nodeStream, vatWorkerClient, kvStore); - await kernel.init(); - - return kernel; -} - -/** - * Runs the full lifecycle of an array of vats, including their creation, - * restart, message passing, and termination. - * - * @param kernel The kernel instance. - * @param vats An array of VatIds to be managed. - */ -export async function runVatLifecycle( - kernel: Kernel, - vats: NonEmptyArray, -): Promise { - console.log('runVatLifecycle Start...'); - const vatLabel = vats.join(', '); - console.time(`Created vats: ${vatLabel}`); - await Promise.all( - vats.map( - async () => - await kernel.launchVat({ - bundleSpec: 'http://localhost:3000/sample-vat.bundle', - parameters: { name: 'Nodeen' }, - }), - ), - ); - console.timeEnd(`Created vats: ${vatLabel}`); - const knownVats = kernel.getVatIds() as NonEmptyArray; - const knownVatsLabel = knownVats.join(', '); - console.log('Kernel vats:', knownVatsLabel); - - // Restart a randomly selected vat from the array. - console.time(`Restart vats: ${knownVatsLabel}`); - await Promise.all( - knownVats.map(async (vatId: VatId) => await kernel.restartVat(vatId)), - ); - console.timeEnd(`Restart vats: ${knownVatsLabel}`); - - // Send a "Ping" message to a randomly selected vat. - console.time(`Ping vats: ${knownVatsLabel}`); - await Promise.all( - knownVats.map( - async (vatId: VatId) => - await kernel.sendMessage(vatId, { - method: VatCommandMethod.ping, - params: null, - }), - ), - ); - console.timeEnd(`Ping vats "${knownVatsLabel}"`); - - console.time(`Terminated vats: ${knownVatsLabel}`); - await kernel.terminateAllVats(); - console.timeEnd(`Terminated vats: ${knownVatsLabel}`); - - console.log(`Kernel has ${kernel.getVatIds().length} vats`); -} diff --git a/packages/nodejs/src/kernel/make-kernel.test.ts b/packages/nodejs/src/kernel/make-kernel.test.ts new file mode 100644 index 000000000..b76718de9 --- /dev/null +++ b/packages/nodejs/src/kernel/make-kernel.test.ts @@ -0,0 +1,24 @@ +import '@ocap/shims/endoify'; + +import { Kernel } from '@ocap/kernel'; +import { + MessagePort as NodeMessagePort, + MessageChannel as NodeMessageChannel, +} from 'node:worker_threads'; +import { beforeEach, describe, expect, it } from 'vitest'; + +import { makeKernel } from './make-kernel.js'; + +describe('makeKernel', () => { + let kernelPort: NodeMessagePort; + + beforeEach(() => { + kernelPort = new NodeMessageChannel().port1; + }); + + it('should return a Kernel', async () => { + const kernel = await makeKernel(kernelPort); + + expect(kernel).toBeInstanceOf(Kernel); + }); +}); diff --git a/packages/nodejs/src/kernel/make-kernel.ts b/packages/nodejs/src/kernel/make-kernel.ts new file mode 100644 index 000000000..710ddd607 --- /dev/null +++ b/packages/nodejs/src/kernel/make-kernel.ts @@ -0,0 +1,34 @@ +import type { KernelCommand, KernelCommandReply } from '@ocap/kernel'; +import { Kernel } from '@ocap/kernel'; +import { NodeWorkerDuplexStream } from '@ocap/streams'; +import { MessagePort as NodeMessagePort } from 'node:worker_threads'; + +import { makeSQLKVStore } from './sqlite-kv-store.js'; +import { NodejsVatWorkerService } from './VatWorkerService.js'; + +/** + * The main function for the kernel worker. + * + * @param port - The kernel's end of a node:worker_threads MessageChannel + * @param workerFilePath - The path to a file defining each vat worker's routine. + * @returns The kernel, initialized. + */ +export async function makeKernel( + port: NodeMessagePort, + workerFilePath?: string, +): Promise { + const nodeStream = new NodeWorkerDuplexStream< + KernelCommand, + KernelCommandReply + >(port); + const vatWorkerClient = new NodejsVatWorkerService(workerFilePath); + + // Initialize kernel store. + const kvStore = await makeSQLKVStore(); + + // Create and start kernel. + const kernel = new Kernel(nodeStream, vatWorkerClient, kvStore); + await kernel.init(); + + return kernel; +} diff --git a/packages/nodejs/src/vat-worker.ts b/packages/nodejs/src/vat-worker.ts deleted file mode 100644 index b38aaac6f..000000000 --- a/packages/nodejs/src/vat-worker.ts +++ /dev/null @@ -1,25 +0,0 @@ -import '@ocap/shims/endoify'; - -import type { VatId } from '@ocap/kernel'; -import { makeLogger } from '@ocap/utils'; - -import { makeSQLKVStore } from './kernel/sqlite-kv-store.js'; -import { makeMultiplexer } from './vat/make-multiplexer.js'; -import { makeVatWorker } from './vat/make-vat-worker.js'; - -const vatId = process.env.NODE_VAT_ID as VatId; - -if (vatId) { - const logger = makeLogger(`[vat-worker (${vatId})]`); - logger.debug('starting worker...'); - const { start, stop } = makeVatWorker(vatId, makeMultiplexer, makeSQLKVStore); - try { - await start(); - } catch (problem) { - logger.error(problem); - } finally { - await stop(); - } -} else { - console.log('no vatId set for env variable NODE_VAT_ID'); -} diff --git a/packages/nodejs/src/vat/make-multiplexer.test.ts b/packages/nodejs/src/vat/make-multiplexer.test.ts index 640c030b7..6b17f8c38 100644 --- a/packages/nodejs/src/vat/make-multiplexer.test.ts +++ b/packages/nodejs/src/vat/make-multiplexer.test.ts @@ -2,28 +2,44 @@ import '@ocap/shims/endoify'; import { describe, expect, it, vi } from 'vitest'; -describe('getPort', () => { - it('returns a port', async () => { - const mockParentPort = {}; - vi.doMock('node:worker_threads', () => ({ - parentPort: mockParentPort, - })); - vi.resetModules(); - - const { getPort } = await import('./make-multiplexer.js'); - - const port = getPort(); +import type { + getPort as getPortImpl, + makeMultiplexer as makeMultiplexerImpl, +} from './make-multiplexer.js'; + +type GetPort = typeof getPortImpl; +type MakeMultiplexer = typeof makeMultiplexerImpl; + +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +const doMockParentPort = (value: unknown) => { + vi.doMock('node:worker_threads', () => ({ + parentPort: value, + })); + vi.resetModules(); +}; - expect(port).toStrictEqual(mockParentPort); - }); +describe('getPort', () => { + it( + 'returns a port', + async () => { + const mockParentPort = {}; + doMockParentPort(mockParentPort); + + const { getPort } = await vi.importActual('./make-multiplexer.js'); + const port = (getPort as GetPort)(); + + expect(port).toStrictEqual(mockParentPort); + }, + { + // Extra time is needed when running yarn test from monorepo root. + timeout: 5000, + }, + ); it('throws if parentPort is not defined', async () => { - vi.doMock('node:worker_threads', () => ({ - parentPort: undefined, - })); - vi.resetModules(); + doMockParentPort(undefined); - const { getPort } = await import('./make-multiplexer.js'); + const { getPort } = await vi.importActual('./make-multiplexer.js'); expect(getPort).toThrow(/parentPort/u); }); @@ -31,13 +47,10 @@ describe('getPort', () => { describe('makeMultiplexer', () => { it('returns a NodeWorkerMultiplexer', async () => { - vi.doMock('node:worker_threads', () => ({ - parentPort: new MessageChannel().port1, - })); - vi.resetModules(); - const { NodeWorkerMultiplexer } = await import('@ocap/streams'); - const { makeMultiplexer } = await import('./make-multiplexer.js'); - const multiplexer = makeMultiplexer('v0'); + doMockParentPort(new MessageChannel().port1); + const { NodeWorkerMultiplexer } = await vi.importActual('@ocap/streams'); + const { makeMultiplexer } = await vi.importActual('./make-multiplexer.js'); + const multiplexer = (makeMultiplexer as MakeMultiplexer)(); expect(multiplexer).toBeInstanceOf(NodeWorkerMultiplexer); }); }); diff --git a/packages/nodejs/src/vat/make-multiplexer.ts b/packages/nodejs/src/vat/make-multiplexer.ts index c75d3f007..f4153316f 100644 --- a/packages/nodejs/src/vat/make-multiplexer.ts +++ b/packages/nodejs/src/vat/make-multiplexer.ts @@ -11,6 +11,7 @@ import { parentPort } from 'node:worker_threads'; export function getPort() { if (!parentPort) { const errMsg = 'Expected to run in Node Worker with parentPort.'; + console.error(errMsg); throw new Error(errMsg); } return parentPort; @@ -20,9 +21,8 @@ export function getPort() { * When called from within Node.js worker, returns a Multiplexer which * communicates over the parentPort. * - * @param name - The name to give this multiplexer (for traffic logging). * @returns A NodeWorkerMultiplexer */ -export function makeMultiplexer(name?: string): NodeWorkerMultiplexer { - return new NodeWorkerMultiplexer(getPort(), name); +export function makeMultiplexer(): NodeWorkerMultiplexer { + return new NodeWorkerMultiplexer(getPort(), 'vat'); } diff --git a/packages/nodejs/src/vat/make-vat-worker.test.ts b/packages/nodejs/src/vat/make-vat-worker.test.ts index ad6063728..a9b2d8009 100644 --- a/packages/nodejs/src/vat/make-vat-worker.test.ts +++ b/packages/nodejs/src/vat/make-vat-worker.test.ts @@ -1,16 +1,19 @@ import '@ocap/shims/endoify'; +import type { VatSupervisor } from '@ocap/kernel'; import { beforeEach, describe, expect, it, vi } from 'vitest'; +import type { Mock } from 'vitest'; import { makeMultiplexer } from './make-multiplexer.js'; -import { makeVatWorker as makeVatWorkerDecl } from './make-vat-worker.js'; +import { startVatWorker as startVatWorkerDecl } from './make-vat-worker.js'; -type MakeVatWorker = typeof makeVatWorkerDecl; +type MakeVatWorker = typeof startVatWorkerDecl; -describe('makeVatWorker', () => { +describe('startVatWorker', () => { const testVatId = 'v0'; - let makeVatWorker: MakeVatWorker; - let mockMakeMultiplexer: typeof makeMultiplexer; + let startVatWorker: MakeVatWorker; + let mockMakeMultiplexer: Mock; + let MockVatSupervisor: Mock<() => VatSupervisor>; beforeEach(async () => { mockMakeMultiplexer = vi.fn().mockImplementation(() => ({ @@ -18,50 +21,38 @@ describe('makeVatWorker', () => { return: vi.fn().mockResolvedValue(undefined), createChannel: vi.fn(), })); + MockVatSupervisor = vi.fn().mockImplementation(() => ({ + terminate: vi.fn().mockResolvedValue(undefined), + })); vi.doMock('@ocap/streams', () => ({ NodeWorkerMultiplexer: vi.fn(), })); vi.doMock('@ocap/kernel', () => ({ - VatSupervisor: vi.fn().mockImplementation(() => ({ - terminate: vi.fn().mockResolvedValue(undefined), - })), + VatSupervisor: MockVatSupervisor, isVatCommand: vi.fn(), })); vi.resetModules(); - makeVatWorker = (await import('./make-vat-worker.js')).makeVatWorker; + startVatWorker = (await import('./make-vat-worker.js')).startVatWorker; }); - it('returns an object with start and stop methods', async () => { - const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); - - expect(vatWorker).toHaveProperty('start'); - expect(vatWorker).toHaveProperty('stop'); + it('creates a multiplexer and channel and calls start', async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + await startVatWorker(testVatId, mockMakeMultiplexer, {} as any); + + expect(mockMakeMultiplexer).toHaveBeenCalledOnce(); + expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); + expect( + mockMakeMultiplexer.mock.results.at(0)?.value.createChannel, + ).toHaveBeenCalledOnce(); + expect( + mockMakeMultiplexer.mock.results.at(0)?.value.start, + ).toHaveBeenCalledOnce(); }); - describe('start', () => { - it('starts the multiplexer', async () => { - const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); - - await vatWorker.start(); - - expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); - expect( - mockMakeMultiplexer.mock.results.at(0).value.start, - ).toHaveBeenCalledOnce(); - }); - }); - - describe('stop', () => { - it('calls supervisor.terminate and multiplexer.return', async () => { - const vatWorker = makeVatWorker(testVatId, mockMakeMultiplexer); - - await vatWorker.start(); - await vatWorker.stop(); + it('creates a VatSupervisor', async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + await startVatWorker(testVatId, mockMakeMultiplexer, {} as any); - expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); - expect( - mockMakeMultiplexer.mock.results.at(0).value.return, - ).toHaveBeenCalledOnce(); - }); + expect(MockVatSupervisor.mock.instances).toHaveLength(1); }); }); diff --git a/packages/nodejs/src/vat/make-vat-worker.ts b/packages/nodejs/src/vat/make-vat-worker.ts index 7260ceddc..f7f500f91 100644 --- a/packages/nodejs/src/vat/make-vat-worker.ts +++ b/packages/nodejs/src/vat/make-vat-worker.ts @@ -15,33 +15,23 @@ import type { StreamMultiplexer } from '@ocap/streams'; * @param makeKVStore - A routine to make a KVStore for the VatSupervisor. * @returns A vat worker object with awaitable start and stop methods. */ -export function makeVatWorker( +export async function startVatWorker( vatId: VatId, makeMultiplexer: (name?: string) => StreamMultiplexer, makeKVStore: MakeKVStore, -): { - start: () => Promise; - stop: () => Promise; -} { +): Promise { const multiplexer = makeMultiplexer(vatId); + // We must start the multiplexer here, not later. + multiplexer.start().catch(console.error); const commandStream = multiplexer.createChannel( 'command', isVatCommand, ); - const supervisor = new VatSupervisor({ + // eslint-disable-next-line no-new + new VatSupervisor({ id: `S${vatId}`, commandStream, makeKVStore, }); - - return { - start: async () => { - await multiplexer.start(); - }, - stop: async () => { - await supervisor.terminate(); - await multiplexer.return(); - }, - }; } diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts new file mode 100644 index 000000000..2767c3cce --- /dev/null +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -0,0 +1,19 @@ +import '@ocap/shims/endoify'; + +import type { VatId } from '@ocap/kernel'; +import { makeLogger } from '@ocap/utils'; + +import { makeMultiplexer } from './make-multiplexer.js'; +import { startVatWorker } from './make-vat-worker.js'; +import { makeSQLKVStore } from '../kernel/sqlite-kv-store.js'; + +const vatId = process.env.NODE_VAT_ID as VatId; + +if (vatId) { + console.log('vatId', vatId); + const logger = makeLogger(`[vat-worker (${vatId})]`); + logger.debug('starting worker...'); + startVatWorker(vatId, makeMultiplexer, makeSQLKVStore).catch(logger.error); +} else { + console.log('no vatId set for env variable NODE_VAT_ID'); +} diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 25dc13f4c..65a3f4971 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -1,9 +1,19 @@ import '@ocap/shims/endoify'; -import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; -import { describe, it, expect, vi } from 'vitest'; +import type { NonEmptyArray } from '@metamask/utils'; +import { Kernel, VatCommandMethod } from '@ocap/kernel'; +import type { VatConfig, VatId } from '@ocap/kernel'; +import { + MessageChannel as NodeMessageChannel, + MessagePort as NodePort, + Worker as NodeWorker, +} from 'node:worker_threads'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; -import { makeKernel, runVatLifecycle } from '../../src/kernel/kernel-worker.js'; +import { makeKernel } from '../../src/kernel/make-kernel.js'; + +const workerFileURL = new URL('../../dist/vat-worker.mjs', import.meta.url) + .pathname; vi.mock('node:process', () => ({ exit: vi.fn((reason) => { @@ -12,12 +22,53 @@ vi.mock('node:process', () => ({ })); describe('Kernel Worker', () => { + let kernelPort: NodePort; + let kernel: Kernel; + + const testVatConfig: VatConfig = { + bundleSpec: 'http://localhost:3000/sample-vat.bundle', + parameters: { name: 'Nodeen' }, + }; + + beforeEach(() => { + if (kernelPort) { + kernelPort.close(); + } + kernelPort = new NodeMessageChannel().port1; + }); + + afterEach(async () => { + if (kernel) { + await kernel.terminateAllVats(); + await kernel.clearStorage(); + } + }); + + it('starts a NodeWorker', async () => { + const worker = new NodeWorker(workerFileURL); + expect(worker).toBeInstanceOf(NodeWorker); + }); + + it('makes a Kernel', async () => { + kernel = await makeKernel(kernelPort); + expect(kernel).toBeInstanceOf(Kernel); + }); + + it('creates a vat', async () => { + kernel = await makeKernel(kernelPort); + let vatIds: VatId[] = kernel.getVatIds(); + expect(vatIds).toHaveLength(0); + + const kRef = await kernel.launchVat(testVatConfig); + expect(kRef).toBeInstanceOf(String); + vatIds = kernel.getVatIds(); + expect(vatIds).toHaveLength(1); + }); + it('should handle the lifecycle of multiple vats', async () => { console.log('Started test.'); - const kernelChannel = new NodeMessageChannel(); - const { port1: kernelPort } = kernelChannel; console.log('Creating kernel...'); - const kernel = await makeKernel(kernelPort); + kernel = await makeKernel(kernelPort); console.log('Kernel created.'); console.log('Handling the lifecycle of multiple vats...'); @@ -28,3 +79,58 @@ describe('Kernel Worker', () => { expect(true).toBe(true); }); }); + +/** + * Runs the full lifecycle of an array of vats, including their creation, + * restart, message passing, and termination. + * + * @param kernel The kernel instance. + * @param vats An array of VatIds to be managed. + * @param vatConfig The config to pass for vat initialization. + */ +export async function runVatLifecycle( + kernel: Kernel, + vats: NonEmptyArray, + vatConfig: VatConfig = { + bundleSpec: 'http://localhost:3000/sample-vat.bundle', + parameters: { name: 'Nodeen' }, + }, +): Promise { + console.log('runVatLifecycle Start...'); + const vatLabel = vats.join(', '); + console.time(`Created vats: ${vatLabel}`); + const kRef = await kernel.launchVat(vatConfig); + console.debug('kref', kRef); + + await Promise.all(vats.map(async () => await kernel.launchVat(vatConfig))); + console.timeEnd(`Created vats: ${vatLabel}`); + const knownVats = kernel.getVatIds() as NonEmptyArray; + const knownVatsLabel = knownVats.join(', '); + console.log('Kernel vats:', knownVatsLabel); + + // Restart a randomly selected vat from the array. + console.time(`Restart vats: ${knownVatsLabel}`); + await Promise.all( + knownVats.map(async (vatId: VatId) => await kernel.restartVat(vatId)), + ); + console.timeEnd(`Restart vats: ${knownVatsLabel}`); + + // Send a "Ping" message to a randomly selected vat. + console.time(`Ping vats: ${knownVatsLabel}`); + await Promise.all( + knownVats.map( + async (vatId: VatId) => + await kernel.sendMessage(vatId, { + method: VatCommandMethod.ping, + params: null, + }), + ), + ); + console.timeEnd(`Ping vats "${knownVatsLabel}"`); + + console.time(`Terminated vats: ${knownVatsLabel}`); + await kernel.terminateAllVats(); + console.timeEnd(`Terminated vats: ${knownVatsLabel}`); + + console.log(`Kernel has ${kernel.getVatIds().length} vats`); +} diff --git a/packages/nodejs/test/workers/hello-world.mjs b/packages/nodejs/test/workers/hello-world.mjs new file mode 100644 index 000000000..fa438c34a --- /dev/null +++ b/packages/nodejs/test/workers/hello-world.mjs @@ -0,0 +1,3 @@ +import '@ocap/shims/endoify'; + +console.debug('hello, world computer'); diff --git a/packages/nodejs/test/workers/index.ts b/packages/nodejs/test/workers/index.ts new file mode 100644 index 000000000..60c82437b --- /dev/null +++ b/packages/nodejs/test/workers/index.ts @@ -0,0 +1,2 @@ +export const getTestWorkerFile = (name: string): string => + new URL(`./${name}.mjs`, import.meta.url).pathname; diff --git a/packages/nodejs/test/workers/ping-pong.mjs b/packages/nodejs/test/workers/ping-pong.mjs new file mode 100644 index 000000000..9533bf1b2 --- /dev/null +++ b/packages/nodejs/test/workers/ping-pong.mjs @@ -0,0 +1,13 @@ +import '@ocap/shims/endoify'; + +import { makeMultiplexer } from '../../src/vat/make-multiplexer.mjs'; + +main().catch(console.error); + +/** + * The main function for the worker. TODO: support pinging and ponging. + */ +async function main() { + const multiplexer = makeMultiplexer('v0'); + await multiplexer.start(); +} diff --git a/vitest.config.ts b/vitest.config.ts index 2dfb2f545..ce4945637 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -73,10 +73,10 @@ export default defineConfig({ lines: 42.47, }, 'packages/nodejs/**': { - statements: 4.12, - functions: 4.76, - branches: 13.33, - lines: 4.12, + statements: 14.67, + functions: 24, + branches: 23.52, + lines: 14.67, }, 'packages/shims/**': { statements: 0, @@ -105,4 +105,4 @@ export default defineConfig({ }, }, }, -}); +}); \ No newline at end of file From 2ecbebd4628ed82260a7645b881480e30918400c Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 22 Jan 2025 03:37:03 -0600 Subject: [PATCH 07/55] mock make-kernel.test kvStore --- packages/nodejs/src/kernel/make-kernel.test.ts | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/packages/nodejs/src/kernel/make-kernel.test.ts b/packages/nodejs/src/kernel/make-kernel.test.ts index b76718de9..0a304077a 100644 --- a/packages/nodejs/src/kernel/make-kernel.test.ts +++ b/packages/nodejs/src/kernel/make-kernel.test.ts @@ -5,10 +5,17 @@ import { MessagePort as NodeMessagePort, MessageChannel as NodeMessageChannel, } from 'node:worker_threads'; -import { beforeEach, describe, expect, it } from 'vitest'; +import { beforeEach, describe, expect, it, vi } from 'vitest'; import { makeKernel } from './make-kernel.js'; +vi.mock('./sqlite-kv-store.js', async () => { + const { makeMapKVStore } = await import('../../../kernel/test/storage.js'); + return { + makeSQLKVStore: makeMapKVStore, + }; +}); + describe('makeKernel', () => { let kernelPort: NodeMessagePort; From ca850777cdf08f9df5918bcf4fe50ecd15da79a6 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 22 Jan 2025 11:55:43 -0600 Subject: [PATCH 08/55] thresholds --- vitest.config.ts | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/vitest.config.ts b/vitest.config.ts index d2d4737a9..a7863db62 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -74,16 +74,16 @@ export default defineConfig({ lines: 65.92, }, 'packages/kernel/**': { - statements: 42.66, - functions: 54.48, - branches: 29.72, - lines: 42.95, + statements: 44.12, + functions: 55.17, + branches: 30.5, + lines: 44.41, }, 'packages/nodejs/**': { - statements: 14.67, - functions: 24, - branches: 23.52, - lines: 14.67, + statements: 47.61, + functions: 47.36, + branches: 27.77, + lines: 47.61, }, 'packages/shims/**': { statements: 0, @@ -112,4 +112,4 @@ export default defineConfig({ }, }, }, -}); \ No newline at end of file +}); From eea968480192dc31ab7b27002f65cf98288674ff Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 22 Jan 2025 11:56:01 -0600 Subject: [PATCH 09/55] give getPort test more time --- packages/nodejs/src/vat/make-multiplexer.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/nodejs/src/vat/make-multiplexer.test.ts b/packages/nodejs/src/vat/make-multiplexer.test.ts index 6b17f8c38..13f794e06 100644 --- a/packages/nodejs/src/vat/make-multiplexer.test.ts +++ b/packages/nodejs/src/vat/make-multiplexer.test.ts @@ -32,7 +32,7 @@ describe('getPort', () => { }, { // Extra time is needed when running yarn test from monorepo root. - timeout: 5000, + timeout: 12000, }, ); From df25f8ddfb156345381905364a48cb67ab3b0a22 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 22 Jan 2025 16:53:54 -0600 Subject: [PATCH 10/55] more refined --- packages/nodejs/package.json | 2 +- .../src/kernel/VatWorkerService.test.ts | 23 +++---- .../nodejs/src/kernel/VatWorkerService.ts | 1 + packages/nodejs/src/kernel/map-kv-store.ts | 41 ++++++++++++ .../nodejs/src/vat/make-multiplexer.test.ts | 56 ---------------- packages/nodejs/src/vat/make-multiplexer.ts | 28 -------- .../nodejs/src/vat/make-vat-worker.test.ts | 58 ---------------- packages/nodejs/src/vat/make-vat-worker.ts | 37 ----------- packages/nodejs/src/vat/streams.test.ts | 42 ++++++++++++ packages/nodejs/src/vat/streams.ts | 36 ++++++++++ packages/nodejs/src/vat/vat-worker.ts | 66 +++++++++---------- .../nodejs/test/e2e/kernel-worker.test.ts | 13 +++- packages/nodejs/test/workers/hello-world.mjs | 2 +- packages/nodejs/test/workers/ping-pong.mjs | 13 +++- packages/nodejs/test/workers/stream-sync.mjs | 15 +++++ 15 files changed, 197 insertions(+), 236 deletions(-) create mode 100644 packages/nodejs/src/kernel/map-kv-store.ts delete mode 100644 packages/nodejs/src/vat/make-multiplexer.test.ts delete mode 100644 packages/nodejs/src/vat/make-multiplexer.ts delete mode 100644 packages/nodejs/src/vat/make-vat-worker.test.ts delete mode 100644 packages/nodejs/src/vat/make-vat-worker.ts create mode 100644 packages/nodejs/src/vat/streams.test.ts create mode 100644 packages/nodejs/src/vat/streams.ts create mode 100644 packages/nodejs/test/workers/stream-sync.mjs diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 98e18f26d..253b377e2 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -34,7 +34,7 @@ "publish:preview": "yarn npm publish --tag preview", "test": "vitest run --config vitest.config.ts", "test:e2e": "vitest run --config vitest.config.e2e.ts", - "test:e2e:ci": "echo 'skipped tests' || ./scripts/test-e2e-ci.sh", + "test:e2e:ci": "./scripts/test-e2e-ci.sh", "test:clean": "yarn test --no-cache --coverage.clean", "test:dev": "yarn test --coverage false", "test:verbose": "yarn test --reporter verbose", diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index e26bf3c08..d48f53d28 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -1,7 +1,7 @@ import '@ocap/shims/endoify'; import type { VatId } from '@ocap/kernel'; -import { NodeWorkerMultiplexer } from '@ocap/streams'; +import { NodeWorkerDuplexStream } from '@ocap/streams'; import { makeCounter } from '@ocap/utils'; import { describe, expect, it } from 'vitest'; @@ -14,26 +14,23 @@ describe('NodejsVatWorkerService', () => { expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); + const helloWorld = getTestWorkerFile('hello-world'); const vatIdCounter = makeCounter(); const getTestVatId = (): VatId => `v${vatIdCounter()}`; describe('launch', () => { - it('creates a NodeWorker and returns a NodeWorkerMultiplexer', async () => { - const service = new NodejsVatWorkerService( - getTestWorkerFile('hello-world'), - ); + it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { + const service = new NodejsVatWorkerService(helloWorld); const testVatId: VatId = getTestVatId(); const multiplexer = await service.launch(testVatId); - expect(multiplexer).toBeInstanceOf(NodeWorkerMultiplexer); + expect(multiplexer).toBeInstanceOf(NodeWorkerDuplexStream); }); }); describe('terminate', () => { it('terminates the target vat', async () => { - const service = new NodejsVatWorkerService( - getTestWorkerFile('hello-world'), - ); + const service = new NodejsVatWorkerService(helloWorld); const testVatId: VatId = getTestVatId(); await service.launch(testVatId); @@ -44,9 +41,7 @@ describe('NodejsVatWorkerService', () => { }); it('throws when terminating an unknown vat', async () => { - const service = new NodejsVatWorkerService( - getTestWorkerFile('hello-world'), - ); + const service = new NodejsVatWorkerService(helloWorld); const testVatId: VatId = getTestVatId(); await expect( @@ -57,9 +52,7 @@ describe('NodejsVatWorkerService', () => { describe('terminateAll', () => { it('terminates all vats', async () => { - const service = new NodejsVatWorkerService( - getTestWorkerFile('hello-world'), - ); + const service = new NodejsVatWorkerService(helloWorld); const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; await Promise.all( diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 80face1f8..a20a14f2b 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -51,6 +51,7 @@ export class NodejsVatWorkerService implements VatWorkerService { env: { NODE_VAT_ID: vatId, }, + // execArgv: ["--require", "ts-node/register"], }); this.#logger.debug('launched', vatId); worker.once('online', () => { diff --git a/packages/nodejs/src/kernel/map-kv-store.ts b/packages/nodejs/src/kernel/map-kv-store.ts new file mode 100644 index 000000000..042c5fee8 --- /dev/null +++ b/packages/nodejs/src/kernel/map-kv-store.ts @@ -0,0 +1,41 @@ +/** + * This file is a copy of `@ocap/kernel/test/storage.ts` + * Because the test dir isn't shipped, it is easier just to copy than to + * do battle with the existing build configuration. + */ +import type { KVStore } from '@ocap/kernel'; + +/** + * A mock key/value store realized as a Map. + * + * @returns The mock {@link KVStore}. + */ +export function makeMapKVStore(): KVStore { + const map = new Map(); + + /** + * Like `get`, but fail if the key isn't there. + * + * @param key - The key to fetch. + * @returns The value at `key`. + */ + function getRequired(key: string): string { + const result = map.get(key); + if (result === undefined) { + throw Error(`No value found for key ${key}.`); + } + return result; + } + + return { + get: map.get.bind(map), + getNextKey: (_key: string): string | undefined => { + throw Error(`mock store does not (yet) support getNextKey`); + }, + getRequired, + set: map.set.bind(map), + delete: map.delete.bind(map), + clear: map.clear.bind(map), + executeQuery: () => [], + }; +} diff --git a/packages/nodejs/src/vat/make-multiplexer.test.ts b/packages/nodejs/src/vat/make-multiplexer.test.ts deleted file mode 100644 index 13f794e06..000000000 --- a/packages/nodejs/src/vat/make-multiplexer.test.ts +++ /dev/null @@ -1,56 +0,0 @@ -import '@ocap/shims/endoify'; - -import { describe, expect, it, vi } from 'vitest'; - -import type { - getPort as getPortImpl, - makeMultiplexer as makeMultiplexerImpl, -} from './make-multiplexer.js'; - -type GetPort = typeof getPortImpl; -type MakeMultiplexer = typeof makeMultiplexerImpl; - -// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -const doMockParentPort = (value: unknown) => { - vi.doMock('node:worker_threads', () => ({ - parentPort: value, - })); - vi.resetModules(); -}; - -describe('getPort', () => { - it( - 'returns a port', - async () => { - const mockParentPort = {}; - doMockParentPort(mockParentPort); - - const { getPort } = await vi.importActual('./make-multiplexer.js'); - const port = (getPort as GetPort)(); - - expect(port).toStrictEqual(mockParentPort); - }, - { - // Extra time is needed when running yarn test from monorepo root. - timeout: 12000, - }, - ); - - it('throws if parentPort is not defined', async () => { - doMockParentPort(undefined); - - const { getPort } = await vi.importActual('./make-multiplexer.js'); - - expect(getPort).toThrow(/parentPort/u); - }); -}); - -describe('makeMultiplexer', () => { - it('returns a NodeWorkerMultiplexer', async () => { - doMockParentPort(new MessageChannel().port1); - const { NodeWorkerMultiplexer } = await vi.importActual('@ocap/streams'); - const { makeMultiplexer } = await vi.importActual('./make-multiplexer.js'); - const multiplexer = (makeMultiplexer as MakeMultiplexer)(); - expect(multiplexer).toBeInstanceOf(NodeWorkerMultiplexer); - }); -}); diff --git a/packages/nodejs/src/vat/make-multiplexer.ts b/packages/nodejs/src/vat/make-multiplexer.ts deleted file mode 100644 index f4153316f..000000000 --- a/packages/nodejs/src/vat/make-multiplexer.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { NodeWorkerMultiplexer } from '@ocap/streams'; -import { parentPort } from 'node:worker_threads'; - -/** - * Return the parent port of the Node.js worker if it exists; otherwise throw. - * - * @returns The parent port. - * @throws If not called from within a Node.js worker. - */ -// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -export function getPort() { - if (!parentPort) { - const errMsg = 'Expected to run in Node Worker with parentPort.'; - console.error(errMsg); - throw new Error(errMsg); - } - return parentPort; -} - -/** - * When called from within Node.js worker, returns a Multiplexer which - * communicates over the parentPort. - * - * @returns A NodeWorkerMultiplexer - */ -export function makeMultiplexer(): NodeWorkerMultiplexer { - return new NodeWorkerMultiplexer(getPort(), 'vat'); -} diff --git a/packages/nodejs/src/vat/make-vat-worker.test.ts b/packages/nodejs/src/vat/make-vat-worker.test.ts deleted file mode 100644 index a9b2d8009..000000000 --- a/packages/nodejs/src/vat/make-vat-worker.test.ts +++ /dev/null @@ -1,58 +0,0 @@ -import '@ocap/shims/endoify'; - -import type { VatSupervisor } from '@ocap/kernel'; -import { beforeEach, describe, expect, it, vi } from 'vitest'; -import type { Mock } from 'vitest'; - -import { makeMultiplexer } from './make-multiplexer.js'; -import { startVatWorker as startVatWorkerDecl } from './make-vat-worker.js'; - -type MakeVatWorker = typeof startVatWorkerDecl; - -describe('startVatWorker', () => { - const testVatId = 'v0'; - let startVatWorker: MakeVatWorker; - let mockMakeMultiplexer: Mock; - let MockVatSupervisor: Mock<() => VatSupervisor>; - - beforeEach(async () => { - mockMakeMultiplexer = vi.fn().mockImplementation(() => ({ - start: vi.fn().mockResolvedValue(undefined), - return: vi.fn().mockResolvedValue(undefined), - createChannel: vi.fn(), - })); - MockVatSupervisor = vi.fn().mockImplementation(() => ({ - terminate: vi.fn().mockResolvedValue(undefined), - })); - vi.doMock('@ocap/streams', () => ({ - NodeWorkerMultiplexer: vi.fn(), - })); - vi.doMock('@ocap/kernel', () => ({ - VatSupervisor: MockVatSupervisor, - isVatCommand: vi.fn(), - })); - vi.resetModules(); - startVatWorker = (await import('./make-vat-worker.js')).startVatWorker; - }); - - it('creates a multiplexer and channel and calls start', async () => { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - await startVatWorker(testVatId, mockMakeMultiplexer, {} as any); - - expect(mockMakeMultiplexer).toHaveBeenCalledOnce(); - expect(mockMakeMultiplexer.mock.results.at(0)).toBeDefined(); - expect( - mockMakeMultiplexer.mock.results.at(0)?.value.createChannel, - ).toHaveBeenCalledOnce(); - expect( - mockMakeMultiplexer.mock.results.at(0)?.value.start, - ).toHaveBeenCalledOnce(); - }); - - it('creates a VatSupervisor', async () => { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - await startVatWorker(testVatId, mockMakeMultiplexer, {} as any); - - expect(MockVatSupervisor.mock.instances).toHaveLength(1); - }); -}); diff --git a/packages/nodejs/src/vat/make-vat-worker.ts b/packages/nodejs/src/vat/make-vat-worker.ts deleted file mode 100644 index f7f500f91..000000000 --- a/packages/nodejs/src/vat/make-vat-worker.ts +++ /dev/null @@ -1,37 +0,0 @@ -import { isVatCommand, VatSupervisor } from '@ocap/kernel'; -import type { - MakeKVStore, - VatCommand, - VatCommandReply, - VatId, -} from '@ocap/kernel'; -import type { StreamMultiplexer } from '@ocap/streams'; - -/** - * Assemble a vat worker for the target environment. - * - * @param vatId - The id of the vat inside the worker. - * @param makeMultiplexer - A routine to make a Multiplexer for the VatSupervisor. - * @param makeKVStore - A routine to make a KVStore for the VatSupervisor. - * @returns A vat worker object with awaitable start and stop methods. - */ -export async function startVatWorker( - vatId: VatId, - makeMultiplexer: (name?: string) => StreamMultiplexer, - makeKVStore: MakeKVStore, -): Promise { - const multiplexer = makeMultiplexer(vatId); - // We must start the multiplexer here, not later. - multiplexer.start().catch(console.error); - const commandStream = multiplexer.createChannel( - 'command', - isVatCommand, - ); - - // eslint-disable-next-line no-new - new VatSupervisor({ - id: `S${vatId}`, - commandStream, - makeKVStore, - }); -} diff --git a/packages/nodejs/src/vat/streams.test.ts b/packages/nodejs/src/vat/streams.test.ts new file mode 100644 index 000000000..26fc7f8f2 --- /dev/null +++ b/packages/nodejs/src/vat/streams.test.ts @@ -0,0 +1,42 @@ +import '../../../test-utils/src/env/mock-endoify.js'; + +import { describe, expect, it, vi } from 'vitest'; + +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +const doMockParentPort = (value: unknown) => { + vi.doMock('node:worker_threads', () => ({ + parentPort: value, + })); + vi.resetModules(); +}; + +describe('getPort', () => { + it('returns a port', async () => { + const mockParentPort = {}; + doMockParentPort(mockParentPort); + + const { getPort } = await import('./streams.js'); + const port = getPort(); + + expect(port).toStrictEqual(mockParentPort); + }, 4000); // Extra time is needed when running yarn test from monorepo root. + + it('throws if parentPort is not defined', async () => { + doMockParentPort(undefined); + + const { getPort } = await import('./streams.js'); + + expect(getPort).toThrow(/parentPort/u); + }); +}); + +describe('makeCommandStream', () => { + it('returns a NodeWorkerDuplexStream', async () => { + doMockParentPort(new MessageChannel().port1); + + const { NodeWorkerDuplexStream } = await import('@ocap/streams'); + const { makeCommandStream } = await import('./streams.js'); + const commandStream = makeCommandStream(); + expect(commandStream).toBeInstanceOf(NodeWorkerDuplexStream); + }); +}); diff --git a/packages/nodejs/src/vat/streams.ts b/packages/nodejs/src/vat/streams.ts new file mode 100644 index 000000000..4c19e7eb6 --- /dev/null +++ b/packages/nodejs/src/vat/streams.ts @@ -0,0 +1,36 @@ +import '@ocap/shims/endoify'; + +import { isVatCommand } from '@ocap/kernel'; +import type { VatCommand, VatCommandReply } from '@ocap/kernel'; +import { NodeWorkerDuplexStream } from '@ocap/streams'; +import { parentPort } from 'node:worker_threads'; + +/** + * Return the parent port of the Node.js worker if it exists; otherwise throw. + * + * @returns The parent port. + * @throws If not called from within a Node.js worker. + */ +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +export function getPort() { + if (!parentPort) { + throw new Error('Expected to run in a Node.js worker with parentPort.'); + } + return parentPort; +} + +/** + * When called from within Node.js worker, returns a DuplexStream which + * communicates over the parentPort. + * + * @returns A NodeWorkerDuplexStream + */ +export function makeCommandStream(): NodeWorkerDuplexStream< + VatCommand, + VatCommandReply +> { + return new NodeWorkerDuplexStream( + getPort(), + isVatCommand, + ); +} diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 2ac11492f..142a9f60f 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -1,44 +1,42 @@ import '@ocap/shims/endoify'; import type { VatId } from '@ocap/kernel'; -import { isVatCommand, VatSupervisor } from '@ocap/kernel'; -import type { VatCommand, VatCommandReply } from '@ocap/kernel'; -import { NodeWorkerDuplexStream } from '@ocap/streams'; -import { makeLogger } from '@ocap/utils'; +const streams = '../../dist/vat/streams.mjs'; +const store = '../../dist/kernel/sqlite-kv-store.mjs'; -import { makeMultiplexer } from './make-multiplexer.js'; -import { startVatWorker } from './make-vat-worker.js'; -import { makeSQLKVStore } from '../kernel/sqlite-kv-store.js'; +try { + console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] begin imports`); -const vatId = process.env.NODE_VAT_ID as VatId; + const { VatSupervisor } = await import('@ocap/kernel'); + const { makeLogger } = await import('@ocap/utils'); + const { makeCommandStream } = await import(streams); + const { makeSQLKVStore } = await import(store); -if (vatId) { - console.log('vatId', vatId); - const logger = makeLogger(`[vat-worker (${vatId})]`); - logger.debug('starting worker...'); - main().catch(logger.error) -} else { - console.log('no vatId set for env variable NODE_VAT_ID'); -} + console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] imports complete`); + + const vatId = process.env.NODE_VAT_ID as VatId; + + if (vatId) { + console.log('vatId', vatId); + const logger = makeLogger(`[vat-worker (${vatId})]`); + logger.debug('starting worker...'); + main().catch(logger.error); + } else { + console.log('no vatId set for env variable NODE_VAT_ID'); + } -/** - * The main function for the iframe. - */ -async function main(): Promise { - if (!parentPort) { - const errMsg = 'Expected to run in Node Worker with parentPort.'; - logger.error(errMsg); - throw new Error(errMsg); + /** + * The main function for the iframe. + */ + async function main(): Promise { + // eslint-disable-next-line no-void + void new VatSupervisor({ + id: 'iframe', + commandStream: makeCommandStream(), + makeKVStore: makeSQLKVStore, + }); } - const commandStream = new NodeWorkerDuplexStream( - parentPort, - isVatCommand, - ); - // eslint-disable-next-line no-void - void new VatSupervisor({ - id: 'iframe', - commandStream, - makeKVStore: makeSQLKVStore, - }); +} catch (problem) { + console.error(problem); } diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 65a3f4971..7b15bcd80 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -1,4 +1,5 @@ import '@ocap/shims/endoify'; +// import '../../../test-utils/src/env/mock-endoify.js'; import type { NonEmptyArray } from '@metamask/utils'; import { Kernel, VatCommandMethod } from '@ocap/kernel'; @@ -11,6 +12,7 @@ import { import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; import { makeKernel } from '../../src/kernel/make-kernel.js'; +import { getTestWorkerFile } from 'test/workers/index.js'; const workerFileURL = new URL('../../dist/vat-worker.mjs', import.meta.url) .pathname; @@ -44,8 +46,13 @@ describe('Kernel Worker', () => { } }); + it('trivial', () => { + console.debug('TRIVIAL'); + expect(true).toBe(true); + }); + it('starts a NodeWorker', async () => { - const worker = new NodeWorker(workerFileURL); + const worker = new NodeWorker(getTestWorkerFile('hello-world')); expect(worker).toBeInstanceOf(NodeWorker); }); @@ -63,9 +70,9 @@ describe('Kernel Worker', () => { expect(kRef).toBeInstanceOf(String); vatIds = kernel.getVatIds(); expect(vatIds).toHaveLength(1); - }); + }, 10000); - it('should handle the lifecycle of multiple vats', async () => { + it.skip('should handle the lifecycle of multiple vats', async () => { console.log('Started test.'); console.log('Creating kernel...'); kernel = await makeKernel(kernelPort); diff --git a/packages/nodejs/test/workers/hello-world.mjs b/packages/nodejs/test/workers/hello-world.mjs index fa438c34a..93c4f5091 100644 --- a/packages/nodejs/test/workers/hello-world.mjs +++ b/packages/nodejs/test/workers/hello-world.mjs @@ -1,3 +1,3 @@ import '@ocap/shims/endoify'; -console.debug('hello, world computer'); +console.debug('hello, world computer', process.env.NODE_VAT_ID); diff --git a/packages/nodejs/test/workers/ping-pong.mjs b/packages/nodejs/test/workers/ping-pong.mjs index 9533bf1b2..f5182149a 100644 --- a/packages/nodejs/test/workers/ping-pong.mjs +++ b/packages/nodejs/test/workers/ping-pong.mjs @@ -1,6 +1,10 @@ import '@ocap/shims/endoify'; -import { makeMultiplexer } from '../../src/vat/make-multiplexer.mjs'; +import { VatSupervisor } from '../../../kernel/dist/VatSupervisor.mjs'; +import { makeMapKVStore } from '../../dist/kernel/map-kv-store.mjs'; +import { makeCommandStream } from '../../dist/vat/streams.mjs'; + +console.debug('ping pong'); main().catch(console.error); @@ -8,6 +12,9 @@ main().catch(console.error); * The main function for the worker. TODO: support pinging and ponging. */ async function main() { - const multiplexer = makeMultiplexer('v0'); - await multiplexer.start(); + void new VatSupervisor({ + id: 'iframe', + commandStream: makeCommandStream(), + makeKVStore: makeMapKVStore, + }); } diff --git a/packages/nodejs/test/workers/stream-sync.mjs b/packages/nodejs/test/workers/stream-sync.mjs new file mode 100644 index 000000000..51c635697 --- /dev/null +++ b/packages/nodejs/test/workers/stream-sync.mjs @@ -0,0 +1,15 @@ +import '@ocap/shims/endoify'; + +import { makeCommandStream } from '../../dist/vat/streams.mjs'; + +main().catch(console.error); + +/** + * The main function for the worker. + */ +async function main() { + console.debug('top', process.env.NODE_VAT_ID); + const stream = makeCommandStream(); + await stream.synchronize(); + console.debug('bot', process.env.NODE_VAT_ID); +} From a18237c804cda8cfb0f22dedab435c4c43ad7661 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 23 Jan 2025 12:24:21 -0600 Subject: [PATCH 11/55] fix endo mocking --- packages/nodejs/src/vat/streams.test.ts | 10 +++++++++- packages/nodejs/src/vat/streams.ts | 10 ++++++---- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/packages/nodejs/src/vat/streams.test.ts b/packages/nodejs/src/vat/streams.test.ts index 26fc7f8f2..729f606b1 100644 --- a/packages/nodejs/src/vat/streams.test.ts +++ b/packages/nodejs/src/vat/streams.test.ts @@ -1,4 +1,4 @@ -import '../../../test-utils/src/env/mock-endoify.js'; +import '@ocap/test-utils/mock-endoify'; import { describe, expect, it, vi } from 'vitest'; @@ -10,6 +10,14 @@ const doMockParentPort = (value: unknown) => { vi.resetModules(); }; +vi.mock('@ocap/kernel', async () => { + return { isVatCommand: vi.fn(() => true) }; +}); + +vi.mock('@ocap/streams', () => ({ + NodeWorkerDuplexStream: vi.fn(), +})) + describe('getPort', () => { it('returns a port', async () => { const mockParentPort = {}; diff --git a/packages/nodejs/src/vat/streams.ts b/packages/nodejs/src/vat/streams.ts index 4c19e7eb6..5f453fbde 100644 --- a/packages/nodejs/src/vat/streams.ts +++ b/packages/nodejs/src/vat/streams.ts @@ -1,9 +1,9 @@ -import '@ocap/shims/endoify'; +import '@ocap/test-utils/mock-endoify'; import { isVatCommand } from '@ocap/kernel'; import type { VatCommand, VatCommandReply } from '@ocap/kernel'; import { NodeWorkerDuplexStream } from '@ocap/streams'; -import { parentPort } from 'node:worker_threads'; +import { type MessagePort as NodePort, parentPort } from 'node:worker_threads'; /** * Return the parent port of the Node.js worker if it exists; otherwise throw. @@ -12,7 +12,7 @@ import { parentPort } from 'node:worker_threads'; * @throws If not called from within a Node.js worker. */ // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -export function getPort() { +export function getPort(): NodePort { if (!parentPort) { throw new Error('Expected to run in a Node.js worker with parentPort.'); } @@ -25,7 +25,9 @@ export function getPort() { * * @returns A NodeWorkerDuplexStream */ -export function makeCommandStream(): NodeWorkerDuplexStream< +export function makeCommandStream( + +): NodeWorkerDuplexStream< VatCommand, VatCommandReply > { From 5ce6c792d376d521ce6a4166892eee99f430e3a3 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 23 Jan 2025 12:38:17 -0600 Subject: [PATCH 12/55] remove endoify from Kernel.ts --- packages/kernel/src/Kernel.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 1d902e0ac..0ae10ad24 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -1,4 +1,3 @@ -import '@ocap/shims/endoify'; import { passStyleOf } from '@endo/far'; import type { CapData } from '@endo/marshal'; import { makePromiseKit } from '@endo/promise-kit'; From 4f7fdcef2afab3028f78df5dfe119d88529e6ae4 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 12:27:43 -0600 Subject: [PATCH 13/55] further e2e testing --- .../src/kernel/VatWorkerService.test.ts | 2 +- .../nodejs/src/kernel/VatWorkerService.ts | 1 + packages/nodejs/src/kernel/sqlite-kv-store.ts | 20 ++++-- packages/nodejs/src/vat/streams.ts | 2 - packages/nodejs/src/vat/vat-worker.ts | 66 +++++++++---------- .../nodejs/test/e2e/kernel-worker.test.ts | 9 ++- vitest.config.ts | 10 +-- 7 files changed, 57 insertions(+), 53 deletions(-) diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index d48f53d28..a665deda4 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -14,7 +14,7 @@ describe('NodejsVatWorkerService', () => { expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); - const helloWorld = getTestWorkerFile('hello-world'); + const helloWorld = getTestWorkerFile('stream-sync'); const vatIdCounter = makeCounter(); const getTestVatId = (): VatId => `v${vatIdCounter()}`; diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index a20a14f2b..d9d761e24 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -60,6 +60,7 @@ export class NodejsVatWorkerService implements VatWorkerService { isVatCommandReply, ); this.workers.set(vatId, { worker, stream }); + console.debug('synchronizing...'); stream .synchronize() .then(() => { diff --git a/packages/nodejs/src/kernel/sqlite-kv-store.ts b/packages/nodejs/src/kernel/sqlite-kv-store.ts index d8f2db7b0..66e86720e 100644 --- a/packages/nodejs/src/kernel/sqlite-kv-store.ts +++ b/packages/nodejs/src/kernel/sqlite-kv-store.ts @@ -2,11 +2,14 @@ import { hasProperty, isObject } from '@metamask/utils'; import type { KVStore } from '@ocap/kernel'; import { makeLogger } from '@ocap/utils'; // eslint-disable-next-line @typescript-eslint/naming-convention -import Sqlite from 'better-sqlite3'; +// import Sqlite from 'better-sqlite3'; import { mkdir } from 'fs/promises'; import { tmpdir } from 'os'; import { join } from 'path'; +import type { Database } from 'better-sqlite3'; +const Sqlite = require('better-sqlite3'); + const dbRoot = join(tmpdir(), './db'); /** @@ -17,7 +20,7 @@ const dbRoot = join(tmpdir(), './db'); */ async function initDB( logger?: ReturnType, -): Promise { +): Promise { const dbPath = join(dbRoot, 'store.db'); console.log('dbPath:', dbPath); await mkdir(dbRoot, { recursive: true }); @@ -91,11 +94,16 @@ export async function makeSQLKVStore( * last key in the store. */ function kvGetNextKey(previousKey: string): string | undefined { - if (typeof previousKey !== 'string') { - // eslint-disable-next-line @typescript-eslint/restrict-template-expressions - throw new Error(`previousKey ${previousKey} must be a string`); + try { + if (typeof previousKey !== 'string') { + // eslint-disable-next-line @typescript-eslint/restrict-template-expressions + throw new Error(`previousKey ${previousKey} must be a string`); + } + return sqlKVGetNextKey.get(previousKey) as string | undefined; + } catch (problem) { + console.error('BIG PROBLEM', problem); + throw problem; } - return sqlKVGetNextKey.get(previousKey) as string | undefined; } const sqlKVSet = db.prepare(` diff --git a/packages/nodejs/src/vat/streams.ts b/packages/nodejs/src/vat/streams.ts index 5f453fbde..5df3dd526 100644 --- a/packages/nodejs/src/vat/streams.ts +++ b/packages/nodejs/src/vat/streams.ts @@ -1,5 +1,3 @@ -import '@ocap/test-utils/mock-endoify'; - import { isVatCommand } from '@ocap/kernel'; import type { VatCommand, VatCommandReply } from '@ocap/kernel'; import { NodeWorkerDuplexStream } from '@ocap/streams'; diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 142a9f60f..705695022 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -5,38 +5,36 @@ import type { VatId } from '@ocap/kernel'; const streams = '../../dist/vat/streams.mjs'; const store = '../../dist/kernel/sqlite-kv-store.mjs'; -try { - console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] begin imports`); - - const { VatSupervisor } = await import('@ocap/kernel'); - const { makeLogger } = await import('@ocap/utils'); - const { makeCommandStream } = await import(streams); - const { makeSQLKVStore } = await import(store); - - console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] imports complete`); - - const vatId = process.env.NODE_VAT_ID as VatId; - - if (vatId) { - console.log('vatId', vatId); - const logger = makeLogger(`[vat-worker (${vatId})]`); - logger.debug('starting worker...'); - main().catch(logger.error); - } else { - console.log('no vatId set for env variable NODE_VAT_ID'); - } - - /** - * The main function for the iframe. - */ - async function main(): Promise { - // eslint-disable-next-line no-void - void new VatSupervisor({ - id: 'iframe', - commandStream: makeCommandStream(), - makeKVStore: makeSQLKVStore, - }); - } -} catch (problem) { - console.error(problem); +const { VatSupervisor } = await import('@ocap/kernel'); +const { makeLogger } = await import('@ocap/utils'); +const { makeCommandStream } = await import(streams); +const { makeSQLKVStore } = await import(store); + +console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] imports complete`); + +const vatId = process.env.NODE_VAT_ID as VatId; + +if (vatId) { + console.log('vatId', vatId); + const logger = makeLogger(`[vat-worker (${vatId})]`); + logger.debug('starting worker...'); + main().catch(logger.error); +} else { + console.log('no vatId set for env variable NODE_VAT_ID'); } + +/** + * The main function for the iframe. + */ +async function main(): Promise { + // eslint-disable-next-line no-void + console.debug('entered main'); + const commandStream = makeCommandStream(); + await commandStream.synchronize(); + void new VatSupervisor({ + id: vatId, + commandStream, + makeKVStore: makeSQLKVStore, + }); + console.debug('created supervisor'); +} \ No newline at end of file diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 7b15bcd80..d33f5e18f 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -63,13 +63,12 @@ describe('Kernel Worker', () => { it('creates a vat', async () => { kernel = await makeKernel(kernelPort); - let vatIds: VatId[] = kernel.getVatIds(); - expect(vatIds).toHaveLength(0); - + expect(kernel.getVatIds()).toHaveLength(0); + console.debug('preparing to launch vat') const kRef = await kernel.launchVat(testVatConfig); + console.debug('succsefully to launch vat') expect(kRef).toBeInstanceOf(String); - vatIds = kernel.getVatIds(); - expect(vatIds).toHaveLength(1); + expect(kernel.getVatIds()).toHaveLength(1); }, 10000); it.skip('should handle the lifecycle of multiple vats', async () => { diff --git a/vitest.config.ts b/vitest.config.ts index 8e81f19dd..7dadad60e 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -74,10 +74,10 @@ export default defineConfig({ lines: 68.73, }, 'packages/kernel/**': { - statements: 42.51, - functions: 54.86, - branches: 29.27, - lines: 42.74, + statements: 44.12, + functions: 55.55, + branches: 30.03, + lines: 44.35, }, 'packages/nodejs/**': { statements: 47.61, @@ -112,4 +112,4 @@ export default defineConfig({ }, }, }, -}); +}); \ No newline at end of file From 5ff625f9075228779b430bcbe944bd15dd801d82 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 12:27:58 -0600 Subject: [PATCH 14/55] trace dispatch error --- packages/kernel/src/Kernel.ts | 2 ++ packages/kernel/src/VatHandle.ts | 2 ++ packages/kernel/src/VatSupervisor.ts | 7 +++++++ 3 files changed, 11 insertions(+) diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 0ae10ad24..93d4d3a00 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -278,7 +278,9 @@ export class Kernel { }); this.#vats.set(vatId, vat); this.#storage.initEndpoint(vatId); + console.debug('starting vat init'); await vat.init(); + console.debug('init complete'); const rootRef = this.exportFromVat(vatId, ROOT_OBJECT_VREF); return rootRef; } diff --git a/packages/kernel/src/VatHandle.ts b/packages/kernel/src/VatHandle.ts index 268aaf3f8..93cf40858 100644 --- a/packages/kernel/src/VatHandle.ts +++ b/packages/kernel/src/VatHandle.ts @@ -365,7 +365,9 @@ export class VatHandle { }, ); + this.#logger.debug('pinging...'); await this.sendMessage({ method: VatCommandMethod.ping, params: null }); + this.#logger.debug('pinged!'); await this.sendMessage({ method: VatCommandMethod.initVat, params: this.config, diff --git a/packages/kernel/src/VatSupervisor.ts b/packages/kernel/src/VatSupervisor.ts index 712c57823..2ec81bd41 100644 --- a/packages/kernel/src/VatSupervisor.ts +++ b/packages/kernel/src/VatSupervisor.ts @@ -98,6 +98,7 @@ export class VatSupervisor { * @param message.payload - The payload to handle. */ async handleMessage({ id, payload }: VatCommand): Promise { + console.debug('HANDLEMESSAGE', { id, payload }); switch (payload.method) { case VatCommandMethod.deliver: { if (!this.#dispatch) { @@ -115,7 +116,9 @@ export class VatSupervisor { } case VatCommandMethod.initVat: { + console.debug('CALLING INIT VAT'); const rootObjectVref = await this.#initVat(payload.params); + console.debug('CALLED INIT VAT'); await this.replyToMessage(id, { method: VatCommandMethod.initVat, params: rootObjectVref, @@ -225,7 +228,9 @@ export class VatSupervisor { if (!fetched.ok) { throw Error(`fetch of user code ${bundleSpec} failed: ${fetched.status}`); } + console.debug('fetched bundle'); const bundle = await fetched.json(); + console.debug('and made it json'); const buildVatNamespace = async ( lsEndowments: object, @@ -251,7 +256,9 @@ export class VatSupervisor { this.#dispatch = liveslots.dispatch; const serParam = marshal.toCapData(harden(parameters)) as CapData; + console.debug('CALLING DISPATCH'); await this.#dispatch(harden(['startVat', serParam])); + console.debug('AWAITED DISPATCH'); return ROOT_OBJECT_VREF; } From 2bd4b2c240db274f5fd5816d32003992add82a20 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 13:37:14 -0600 Subject: [PATCH 15/55] get plucky --- packages/nodejs/src/kernel/sqlite-kv-store.ts | 12 ++++-------- packages/nodejs/test/e2e/kernel-worker.test.ts | 6 +++--- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/packages/nodejs/src/kernel/sqlite-kv-store.ts b/packages/nodejs/src/kernel/sqlite-kv-store.ts index 66e86720e..c5088a0e9 100644 --- a/packages/nodejs/src/kernel/sqlite-kv-store.ts +++ b/packages/nodejs/src/kernel/sqlite-kv-store.ts @@ -56,6 +56,7 @@ export async function makeSQLKVStore( FROM kv WHERE key = ? `); + sqlKVGet.pluck(true); /** * Read a key's value from the database. @@ -66,16 +67,10 @@ export async function makeSQLKVStore( */ function kvGet(key: string, required: boolean): string { const result = sqlKVGet.get(key); - if (isObject(result) && hasProperty(result, 'value')) { - const value = result.value as string; - logger.debug(`kernel get '${key}' as '${value}'`); - return value; - } - if (required) { + if (required && !result) { throw Error(`no record matching key '${key}'`); } - // Sometimes, we really lean on TypeScript's unsoundness - return undefined as unknown as string; + return result as string; } const sqlKVGetNextKey = db.prepare(` @@ -84,6 +79,7 @@ export async function makeSQLKVStore( WHERE key > ? LIMIT 1 `); + sqlKVGetNextKey.pluck(true); /** * Get the lexicographically next key in the KV store after a given key. diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index d33f5e18f..2144d3406 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -67,11 +67,11 @@ describe('Kernel Worker', () => { console.debug('preparing to launch vat') const kRef = await kernel.launchVat(testVatConfig); console.debug('succsefully to launch vat') - expect(kRef).toBeInstanceOf(String); + expect(typeof kRef).toStrictEqual('string'); expect(kernel.getVatIds()).toHaveLength(1); - }, 10000); + }); - it.skip('should handle the lifecycle of multiple vats', async () => { + it('should handle the lifecycle of multiple vats', async () => { console.log('Started test.'); console.log('Creating kernel...'); kernel = await makeKernel(kernelPort); From 196f216ddc506119f9e4f62015491b71419f6ac7 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 14:36:14 -0600 Subject: [PATCH 16/55] cleanup --- packages/nodejs/package.json | 2 +- .../src/kernel/VatWorkerService.test.ts | 35 +++-- .../nodejs/src/kernel/VatWorkerService.ts | 7 +- packages/nodejs/src/kernel/sqlite-kv-store.ts | 23 +--- packages/nodejs/src/vat/streams.test.ts | 2 +- packages/nodejs/src/vat/streams.ts | 8 +- packages/nodejs/src/vat/vat-worker.ts | 21 +-- .../nodejs/test/e2e/kernel-worker.test.ts | 130 ++++++------------ packages/nodejs/test/workers/hello-world.mjs | 3 - packages/nodejs/test/workers/ping-pong.mjs | 20 --- packages/nodejs/test/workers/stream-sync.mjs | 8 +- yarn.lock | 2 +- 12 files changed, 90 insertions(+), 171 deletions(-) delete mode 100644 packages/nodejs/test/workers/hello-world.mjs delete mode 100644 packages/nodejs/test/workers/ping-pong.mjs diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 253b377e2..8854840c1 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -47,6 +47,7 @@ "@metamask/eslint-config-nodejs": "^14.0.0", "@metamask/eslint-config-typescript": "^14.0.0", "@ocap/cli": "workspace:^", + "@ocap/test-utils": "workspace:^", "@ts-bridge/cli": "^0.6.2", "@ts-bridge/shims": "^0.1.1", "@types/better-sqlite3": "^7.6.12", @@ -77,7 +78,6 @@ }, "dependencies": { "@endo/promise-kit": "^1.1.6", - "@metamask/utils": "^11.0.1", "@ocap/kernel": "workspace:^", "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index a665deda4..5002a5df3 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -3,7 +3,7 @@ import '@ocap/shims/endoify'; import type { VatId } from '@ocap/kernel'; import { NodeWorkerDuplexStream } from '@ocap/streams'; import { makeCounter } from '@ocap/utils'; -import { describe, expect, it } from 'vitest'; +import { describe, expect, it, vi } from 'vitest'; import { NodejsVatWorkerService } from './VatWorkerService.js'; import { getTestWorkerFile } from '../../test/workers'; @@ -14,23 +14,42 @@ describe('NodejsVatWorkerService', () => { expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); - const helloWorld = getTestWorkerFile('stream-sync'); + const testWorkerFile = getTestWorkerFile('stream-sync'); const vatIdCounter = makeCounter(); const getTestVatId = (): VatId => `v${vatIdCounter()}`; describe('launch', () => { it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { - const service = new NodejsVatWorkerService(helloWorld); + const service = new NodejsVatWorkerService(testWorkerFile); const testVatId: VatId = getTestVatId(); - const multiplexer = await service.launch(testVatId); + const stream = await service.launch(testVatId); - expect(multiplexer).toBeInstanceOf(NodeWorkerDuplexStream); + expect(stream).toBeInstanceOf(NodeWorkerDuplexStream); + }); + + it('rejects if synchronize fails', async () => { + const rejected = 'test-reject-value'; + + vi.doMock('@ocap/streams', () => ({ + NodeWorkerDuplexStream: vi.fn().mockImplementation(() => ({ + synchronize: vi.fn().mockRejectedValue(rejected), + })), + })); + vi.resetModules(); + const NVWS = (await import('./VatWorkerService.js')) + .NodejsVatWorkerService; + + const service = new NVWS(testWorkerFile); + const testVatId: VatId = getTestVatId(); + await expect(async () => await service.launch(testVatId)).rejects.toThrow( + rejected, + ); }); }); describe('terminate', () => { it('terminates the target vat', async () => { - const service = new NodejsVatWorkerService(helloWorld); + const service = new NodejsVatWorkerService(testWorkerFile); const testVatId: VatId = getTestVatId(); await service.launch(testVatId); @@ -41,7 +60,7 @@ describe('NodejsVatWorkerService', () => { }); it('throws when terminating an unknown vat', async () => { - const service = new NodejsVatWorkerService(helloWorld); + const service = new NodejsVatWorkerService(testWorkerFile); const testVatId: VatId = getTestVatId(); await expect( @@ -52,7 +71,7 @@ describe('NodejsVatWorkerService', () => { describe('terminateAll', () => { it('terminates all vats', async () => { - const service = new NodejsVatWorkerService(helloWorld); + const service = new NodejsVatWorkerService(testWorkerFile); const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; await Promise.all( diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index d9d761e24..15bf0363c 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -44,28 +44,25 @@ export class NodejsVatWorkerService implements VatWorkerService { async launch( vatId: VatId, ): Promise> { + this.#logger.debug('launching vat', vatId); const { promise, resolve, reject } = makePromiseKit>(); - this.#logger.debug('launching', vatId); const worker = new NodeWorker(this.#workerFilePath, { env: { NODE_VAT_ID: vatId, }, - // execArgv: ["--require", "ts-node/register"], }); - this.#logger.debug('launched', vatId); worker.once('online', () => { const stream = new NodeWorkerDuplexStream( worker, isVatCommandReply, ); this.workers.set(vatId, { worker, stream }); - console.debug('synchronizing...'); stream .synchronize() .then(() => { resolve(stream); - this.#logger.debug('connected', vatId); + this.#logger.debug('connected to kernel'); return undefined; }) .catch((error) => { diff --git a/packages/nodejs/src/kernel/sqlite-kv-store.ts b/packages/nodejs/src/kernel/sqlite-kv-store.ts index c5088a0e9..0cf698bb0 100644 --- a/packages/nodejs/src/kernel/sqlite-kv-store.ts +++ b/packages/nodejs/src/kernel/sqlite-kv-store.ts @@ -1,13 +1,12 @@ -import { hasProperty, isObject } from '@metamask/utils'; import type { KVStore } from '@ocap/kernel'; import { makeLogger } from '@ocap/utils'; -// eslint-disable-next-line @typescript-eslint/naming-convention -// import Sqlite from 'better-sqlite3'; +import type { Database } from 'better-sqlite3'; import { mkdir } from 'fs/promises'; import { tmpdir } from 'os'; import { join } from 'path'; -import type { Database } from 'better-sqlite3'; +// We require require because the ESM import does not work properly. +// eslint-disable-next-line @typescript-eslint/no-require-imports const Sqlite = require('better-sqlite3'); const dbRoot = join(tmpdir(), './db'); @@ -90,16 +89,11 @@ export async function makeSQLKVStore( * last key in the store. */ function kvGetNextKey(previousKey: string): string | undefined { - try { - if (typeof previousKey !== 'string') { - // eslint-disable-next-line @typescript-eslint/restrict-template-expressions - throw new Error(`previousKey ${previousKey} must be a string`); - } - return sqlKVGetNextKey.get(previousKey) as string | undefined; - } catch (problem) { - console.error('BIG PROBLEM', problem); - throw problem; + if (typeof previousKey !== 'string') { + // eslint-disable-next-line @typescript-eslint/restrict-template-expressions + throw new Error(`previousKey ${previousKey} must be a string`); } + return sqlKVGetNextKey.get(previousKey) as string | undefined; } const sqlKVSet = db.prepare(` @@ -115,7 +109,6 @@ export async function makeSQLKVStore( * @param value - The value to assign to it. */ function kvSet(key: string, value: string): void { - logger.debug(`kernel set '${key}' to '${value}'`); sqlKVSet.run(key, value); } @@ -130,7 +123,6 @@ export async function makeSQLKVStore( * @param key - The key to remove. */ function kvDelete(key: string): void { - logger.debug(`kernel delete '${key}'`); sqlKVDelete.run(key); } @@ -142,7 +134,6 @@ export async function makeSQLKVStore( * Delete all keys and values from the database. */ function kvClear(): void { - logger.debug(`kernel clear`); sqlKVDrop.run(); sqlKVInit.run(); } diff --git a/packages/nodejs/src/vat/streams.test.ts b/packages/nodejs/src/vat/streams.test.ts index 729f606b1..bf9668b15 100644 --- a/packages/nodejs/src/vat/streams.test.ts +++ b/packages/nodejs/src/vat/streams.test.ts @@ -16,7 +16,7 @@ vi.mock('@ocap/kernel', async () => { vi.mock('@ocap/streams', () => ({ NodeWorkerDuplexStream: vi.fn(), -})) +})); describe('getPort', () => { it('returns a port', async () => { diff --git a/packages/nodejs/src/vat/streams.ts b/packages/nodejs/src/vat/streams.ts index 5df3dd526..b3475c356 100644 --- a/packages/nodejs/src/vat/streams.ts +++ b/packages/nodejs/src/vat/streams.ts @@ -1,7 +1,8 @@ import { isVatCommand } from '@ocap/kernel'; import type { VatCommand, VatCommandReply } from '@ocap/kernel'; import { NodeWorkerDuplexStream } from '@ocap/streams'; -import { type MessagePort as NodePort, parentPort } from 'node:worker_threads'; +import { parentPort } from 'node:worker_threads'; +import type { MessagePort as NodePort } from 'node:worker_threads'; /** * Return the parent port of the Node.js worker if it exists; otherwise throw. @@ -9,7 +10,6 @@ import { type MessagePort as NodePort, parentPort } from 'node:worker_threads'; * @returns The parent port. * @throws If not called from within a Node.js worker. */ -// eslint-disable-next-line @typescript-eslint/explicit-function-return-type export function getPort(): NodePort { if (!parentPort) { throw new Error('Expected to run in a Node.js worker with parentPort.'); @@ -23,9 +23,7 @@ export function getPort(): NodePort { * * @returns A NodeWorkerDuplexStream */ -export function makeCommandStream( - -): NodeWorkerDuplexStream< +export function makeCommandStream(): NodeWorkerDuplexStream< VatCommand, VatCommandReply > { diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 705695022..944a59722 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -1,23 +1,16 @@ import '@ocap/shims/endoify'; import type { VatId } from '@ocap/kernel'; +import { VatSupervisor } from '@ocap/kernel'; +import { makeLogger } from '@ocap/utils'; -const streams = '../../dist/vat/streams.mjs'; -const store = '../../dist/kernel/sqlite-kv-store.mjs'; - -const { VatSupervisor } = await import('@ocap/kernel'); -const { makeLogger } = await import('@ocap/utils'); -const { makeCommandStream } = await import(streams); -const { makeSQLKVStore } = await import(store); - -console.debug(`[vat-worker (${process.env.NODE_VAT_ID})] imports complete`); +import { makeCommandStream } from './streams'; +import { makeSQLKVStore } from '../kernel/sqlite-kv-store'; const vatId = process.env.NODE_VAT_ID as VatId; if (vatId) { - console.log('vatId', vatId); const logger = makeLogger(`[vat-worker (${vatId})]`); - logger.debug('starting worker...'); main().catch(logger.error); } else { console.log('no vatId set for env variable NODE_VAT_ID'); @@ -27,14 +20,12 @@ if (vatId) { * The main function for the iframe. */ async function main(): Promise { - // eslint-disable-next-line no-void - console.debug('entered main'); const commandStream = makeCommandStream(); await commandStream.synchronize(); + // eslint-disable-next-line no-void void new VatSupervisor({ id: vatId, commandStream, makeKVStore: makeSQLKVStore, }); - console.debug('created supervisor'); -} \ No newline at end of file +} diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 2144d3406..7fc07dc1e 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -1,21 +1,14 @@ import '@ocap/shims/endoify'; -// import '../../../test-utils/src/env/mock-endoify.js'; -import type { NonEmptyArray } from '@metamask/utils'; import { Kernel, VatCommandMethod } from '@ocap/kernel'; import type { VatConfig, VatId } from '@ocap/kernel'; import { MessageChannel as NodeMessageChannel, MessagePort as NodePort, - Worker as NodeWorker, } from 'node:worker_threads'; import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; import { makeKernel } from '../../src/kernel/make-kernel.js'; -import { getTestWorkerFile } from 'test/workers/index.js'; - -const workerFileURL = new URL('../../dist/vat-worker.mjs', import.meta.url) - .pathname; vi.mock('node:process', () => ({ exit: vi.fn((reason) => { @@ -27,16 +20,20 @@ describe('Kernel Worker', () => { let kernelPort: NodePort; let kernel: Kernel; + // Tests below assume these are sorted for convenience. + const testVatIds = ['v1', 'v2', 'v3'].sort(); + const testVatConfig: VatConfig = { bundleSpec: 'http://localhost:3000/sample-vat.bundle', parameters: { name: 'Nodeen' }, }; - beforeEach(() => { + beforeEach(async () => { if (kernelPort) { kernelPort.close(); } kernelPort = new NodeMessageChannel().port1; + kernel = await makeKernel(kernelPort); }); afterEach(async () => { @@ -46,97 +43,48 @@ describe('Kernel Worker', () => { } }); - it('trivial', () => { - console.debug('TRIVIAL'); - expect(true).toBe(true); + it('launches a vat', async () => { + expect(kernel.getVatIds()).toHaveLength(0); + const kRef = await kernel.launchVat(testVatConfig); + expect(typeof kRef).toBe('string'); + expect(kernel.getVatIds()).toHaveLength(1); }); - it('starts a NodeWorker', async () => { - const worker = new NodeWorker(getTestWorkerFile('hello-world')); - expect(worker).toBeInstanceOf(NodeWorker); - }); + const launchTestVats = async (): Promise => { + await Promise.all( + testVatIds.map(async () => await kernel.launchVat(testVatConfig)), + ); + }; - it('makes a Kernel', async () => { - kernel = await makeKernel(kernelPort); - expect(kernel).toBeInstanceOf(Kernel); - }); + it('restarts vats', async () => { + await launchTestVats(); + expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - it('creates a vat', async () => { - kernel = await makeKernel(kernelPort); - expect(kernel.getVatIds()).toHaveLength(0); - console.debug('preparing to launch vat') - const kRef = await kernel.launchVat(testVatConfig); - console.debug('succsefully to launch vat') - expect(typeof kRef).toStrictEqual('string'); - expect(kernel.getVatIds()).toHaveLength(1); + await Promise.all(testVatIds.map(kernel.restartVat.bind(kernel))); + expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); }); - it('should handle the lifecycle of multiple vats', async () => { - console.log('Started test.'); - console.log('Creating kernel...'); - kernel = await makeKernel(kernelPort); - console.log('Kernel created.'); + it('terminates all vats', async () => { + await launchTestVats(); + expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - console.log('Handling the lifecycle of multiple vats...'); - await runVatLifecycle(kernel, ['v1', 'v2', 'v3']); - console.log('Lifecycle of multiple vats handled.'); + await kernel.terminateAllVats(); + expect(kernel.getVatIds()).toHaveLength(0); + }); - console.log('Test passed.'); + it('pings vats', async () => { + await launchTestVats(); + expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); + + await Promise.all( + testVatIds.map( + async (vatId: VatId) => + await kernel.sendMessage(vatId, { + method: VatCommandMethod.ping, + params: null, + }), + ), + ); expect(true).toBe(true); }); }); - -/** - * Runs the full lifecycle of an array of vats, including their creation, - * restart, message passing, and termination. - * - * @param kernel The kernel instance. - * @param vats An array of VatIds to be managed. - * @param vatConfig The config to pass for vat initialization. - */ -export async function runVatLifecycle( - kernel: Kernel, - vats: NonEmptyArray, - vatConfig: VatConfig = { - bundleSpec: 'http://localhost:3000/sample-vat.bundle', - parameters: { name: 'Nodeen' }, - }, -): Promise { - console.log('runVatLifecycle Start...'); - const vatLabel = vats.join(', '); - console.time(`Created vats: ${vatLabel}`); - const kRef = await kernel.launchVat(vatConfig); - console.debug('kref', kRef); - - await Promise.all(vats.map(async () => await kernel.launchVat(vatConfig))); - console.timeEnd(`Created vats: ${vatLabel}`); - const knownVats = kernel.getVatIds() as NonEmptyArray; - const knownVatsLabel = knownVats.join(', '); - console.log('Kernel vats:', knownVatsLabel); - - // Restart a randomly selected vat from the array. - console.time(`Restart vats: ${knownVatsLabel}`); - await Promise.all( - knownVats.map(async (vatId: VatId) => await kernel.restartVat(vatId)), - ); - console.timeEnd(`Restart vats: ${knownVatsLabel}`); - - // Send a "Ping" message to a randomly selected vat. - console.time(`Ping vats: ${knownVatsLabel}`); - await Promise.all( - knownVats.map( - async (vatId: VatId) => - await kernel.sendMessage(vatId, { - method: VatCommandMethod.ping, - params: null, - }), - ), - ); - console.timeEnd(`Ping vats "${knownVatsLabel}"`); - - console.time(`Terminated vats: ${knownVatsLabel}`); - await kernel.terminateAllVats(); - console.timeEnd(`Terminated vats: ${knownVatsLabel}`); - - console.log(`Kernel has ${kernel.getVatIds().length} vats`); -} diff --git a/packages/nodejs/test/workers/hello-world.mjs b/packages/nodejs/test/workers/hello-world.mjs deleted file mode 100644 index 93c4f5091..000000000 --- a/packages/nodejs/test/workers/hello-world.mjs +++ /dev/null @@ -1,3 +0,0 @@ -import '@ocap/shims/endoify'; - -console.debug('hello, world computer', process.env.NODE_VAT_ID); diff --git a/packages/nodejs/test/workers/ping-pong.mjs b/packages/nodejs/test/workers/ping-pong.mjs deleted file mode 100644 index f5182149a..000000000 --- a/packages/nodejs/test/workers/ping-pong.mjs +++ /dev/null @@ -1,20 +0,0 @@ -import '@ocap/shims/endoify'; - -import { VatSupervisor } from '../../../kernel/dist/VatSupervisor.mjs'; -import { makeMapKVStore } from '../../dist/kernel/map-kv-store.mjs'; -import { makeCommandStream } from '../../dist/vat/streams.mjs'; - -console.debug('ping pong'); - -main().catch(console.error); - -/** - * The main function for the worker. TODO: support pinging and ponging. - */ -async function main() { - void new VatSupervisor({ - id: 'iframe', - commandStream: makeCommandStream(), - makeKVStore: makeMapKVStore, - }); -} diff --git a/packages/nodejs/test/workers/stream-sync.mjs b/packages/nodejs/test/workers/stream-sync.mjs index 51c635697..8cb0d4d01 100644 --- a/packages/nodejs/test/workers/stream-sync.mjs +++ b/packages/nodejs/test/workers/stream-sync.mjs @@ -1,15 +1,13 @@ -import '@ocap/shims/endoify'; - +import '../../dist/env/endoify.mjs'; import { makeCommandStream } from '../../dist/vat/streams.mjs'; main().catch(console.error); /** - * The main function for the worker. + * The main function for the test worker. + * No supervisor is created, but the stream is synchronized for comms testing. */ async function main() { - console.debug('top', process.env.NODE_VAT_ID); const stream = makeCommandStream(); await stream.synchronize(); - console.debug('bot', process.env.NODE_VAT_ID); } diff --git a/yarn.lock b/yarn.lock index 0a83cbd05..920fbfc77 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2286,11 +2286,11 @@ __metadata: "@metamask/eslint-config": "npm:^14.0.0" "@metamask/eslint-config-nodejs": "npm:^14.0.0" "@metamask/eslint-config-typescript": "npm:^14.0.0" - "@metamask/utils": "npm:^11.0.1" "@ocap/cli": "workspace:^" "@ocap/kernel": "workspace:^" "@ocap/shims": "workspace:^" "@ocap/streams": "workspace:^" + "@ocap/test-utils": "workspace:^" "@ocap/utils": "workspace:^" "@ts-bridge/cli": "npm:^0.6.2" "@ts-bridge/shims": "npm:^0.1.1" From 9c257dbd4383332c3f97f16d214d0e740236143d Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 14:46:19 -0600 Subject: [PATCH 17/55] remove debug logs --- packages/kernel/src/Kernel.ts | 2 -- packages/kernel/src/VatHandle.ts | 2 -- packages/kernel/src/VatSupervisor.ts | 7 ------- 3 files changed, 11 deletions(-) diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 93d4d3a00..0ae10ad24 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -278,9 +278,7 @@ export class Kernel { }); this.#vats.set(vatId, vat); this.#storage.initEndpoint(vatId); - console.debug('starting vat init'); await vat.init(); - console.debug('init complete'); const rootRef = this.exportFromVat(vatId, ROOT_OBJECT_VREF); return rootRef; } diff --git a/packages/kernel/src/VatHandle.ts b/packages/kernel/src/VatHandle.ts index 93cf40858..268aaf3f8 100644 --- a/packages/kernel/src/VatHandle.ts +++ b/packages/kernel/src/VatHandle.ts @@ -365,9 +365,7 @@ export class VatHandle { }, ); - this.#logger.debug('pinging...'); await this.sendMessage({ method: VatCommandMethod.ping, params: null }); - this.#logger.debug('pinged!'); await this.sendMessage({ method: VatCommandMethod.initVat, params: this.config, diff --git a/packages/kernel/src/VatSupervisor.ts b/packages/kernel/src/VatSupervisor.ts index 2ec81bd41..712c57823 100644 --- a/packages/kernel/src/VatSupervisor.ts +++ b/packages/kernel/src/VatSupervisor.ts @@ -98,7 +98,6 @@ export class VatSupervisor { * @param message.payload - The payload to handle. */ async handleMessage({ id, payload }: VatCommand): Promise { - console.debug('HANDLEMESSAGE', { id, payload }); switch (payload.method) { case VatCommandMethod.deliver: { if (!this.#dispatch) { @@ -116,9 +115,7 @@ export class VatSupervisor { } case VatCommandMethod.initVat: { - console.debug('CALLING INIT VAT'); const rootObjectVref = await this.#initVat(payload.params); - console.debug('CALLED INIT VAT'); await this.replyToMessage(id, { method: VatCommandMethod.initVat, params: rootObjectVref, @@ -228,9 +225,7 @@ export class VatSupervisor { if (!fetched.ok) { throw Error(`fetch of user code ${bundleSpec} failed: ${fetched.status}`); } - console.debug('fetched bundle'); const bundle = await fetched.json(); - console.debug('and made it json'); const buildVatNamespace = async ( lsEndowments: object, @@ -256,9 +251,7 @@ export class VatSupervisor { this.#dispatch = liveslots.dispatch; const serParam = marshal.toCapData(harden(parameters)) as CapData; - console.debug('CALLING DISPATCH'); await this.#dispatch(harden(['startVat', serParam])); - console.debug('AWAITED DISPATCH'); return ROOT_OBJECT_VREF; } From e1fc71d1ec0989bc1e44ba42c1e09719044057a7 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:08:10 -0600 Subject: [PATCH 18/55] more cleanup --- .../src/kernel/VatWorkerService.test.ts | 20 ++++++--- .../nodejs/src/kernel/VatWorkerService.ts | 14 ++++--- packages/nodejs/src/kernel/make-kernel.ts | 2 +- packages/nodejs/src/kernel/map-kv-store.ts | 41 ------------------- 4 files changed, 24 insertions(+), 53 deletions(-) delete mode 100644 packages/nodejs/src/kernel/map-kv-store.ts diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index 5002a5df3..b53b77f04 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -10,7 +10,7 @@ import { getTestWorkerFile } from '../../test/workers'; describe('NodejsVatWorkerService', () => { it('constructs an instance without any arguments', () => { - const instance = new NodejsVatWorkerService(); + const instance = new NodejsVatWorkerService({}); expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); @@ -20,7 +20,9 @@ describe('NodejsVatWorkerService', () => { describe('launch', () => { it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { - const service = new NodejsVatWorkerService(testWorkerFile); + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); const testVatId: VatId = getTestVatId(); const stream = await service.launch(testVatId); @@ -39,7 +41,7 @@ describe('NodejsVatWorkerService', () => { const NVWS = (await import('./VatWorkerService.js')) .NodejsVatWorkerService; - const service = new NVWS(testWorkerFile); + const service = new NVWS({ workerFilePath: testWorkerFile }); const testVatId: VatId = getTestVatId(); await expect(async () => await service.launch(testVatId)).rejects.toThrow( rejected, @@ -49,7 +51,9 @@ describe('NodejsVatWorkerService', () => { describe('terminate', () => { it('terminates the target vat', async () => { - const service = new NodejsVatWorkerService(testWorkerFile); + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); const testVatId: VatId = getTestVatId(); await service.launch(testVatId); @@ -60,7 +64,9 @@ describe('NodejsVatWorkerService', () => { }); it('throws when terminating an unknown vat', async () => { - const service = new NodejsVatWorkerService(testWorkerFile); + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); const testVatId: VatId = getTestVatId(); await expect( @@ -71,7 +77,9 @@ describe('NodejsVatWorkerService', () => { describe('terminateAll', () => { it('terminates all vats', async () => { - const service = new NodejsVatWorkerService(testWorkerFile); + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; await Promise.all( diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 15bf0363c..6ddcecc7c 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -33,12 +33,16 @@ export class NodejsVatWorkerService implements VatWorkerService { * The vat worker service, intended to be constructed in * the kernel worker. * - * @param workerFilePath - The path to a file defining the worker's routine. - * @param logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'. + * @param args - A bag of optional arguments. + * @param args.workerFilePath - An optional path to a file defining the worker's routine. Defaults to 'vat-worker.mjs'. + * @param args.logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'. */ - constructor(workerFilePath: string = DEFAULT_WORKER_FILE, logger?: Logger) { - this.#workerFilePath = workerFilePath; - this.#logger = logger ?? makeLogger('[vat worker service]'); + constructor(args: { + workerFilePath?: string | undefined; + logger?: Logger | undefined; + }) { + this.#workerFilePath = args.workerFilePath ?? DEFAULT_WORKER_FILE; + this.#logger = args.logger ?? makeLogger('[vat worker service]'); } async launch( diff --git a/packages/nodejs/src/kernel/make-kernel.ts b/packages/nodejs/src/kernel/make-kernel.ts index 710ddd607..aff23f67a 100644 --- a/packages/nodejs/src/kernel/make-kernel.ts +++ b/packages/nodejs/src/kernel/make-kernel.ts @@ -21,7 +21,7 @@ export async function makeKernel( KernelCommand, KernelCommandReply >(port); - const vatWorkerClient = new NodejsVatWorkerService(workerFilePath); + const vatWorkerClient = new NodejsVatWorkerService({ workerFilePath }); // Initialize kernel store. const kvStore = await makeSQLKVStore(); diff --git a/packages/nodejs/src/kernel/map-kv-store.ts b/packages/nodejs/src/kernel/map-kv-store.ts deleted file mode 100644 index 042c5fee8..000000000 --- a/packages/nodejs/src/kernel/map-kv-store.ts +++ /dev/null @@ -1,41 +0,0 @@ -/** - * This file is a copy of `@ocap/kernel/test/storage.ts` - * Because the test dir isn't shipped, it is easier just to copy than to - * do battle with the existing build configuration. - */ -import type { KVStore } from '@ocap/kernel'; - -/** - * A mock key/value store realized as a Map. - * - * @returns The mock {@link KVStore}. - */ -export function makeMapKVStore(): KVStore { - const map = new Map(); - - /** - * Like `get`, but fail if the key isn't there. - * - * @param key - The key to fetch. - * @returns The value at `key`. - */ - function getRequired(key: string): string { - const result = map.get(key); - if (result === undefined) { - throw Error(`No value found for key ${key}.`); - } - return result; - } - - return { - get: map.get.bind(map), - getNextKey: (_key: string): string | undefined => { - throw Error(`mock store does not (yet) support getNextKey`); - }, - getRequired, - set: map.set.bind(map), - delete: map.delete.bind(map), - clear: map.clear.bind(map), - executeQuery: () => [], - }; -} From 6cab7576eebbbebb78dfe8d089e8387fd775d14c Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:11:30 -0600 Subject: [PATCH 19/55] return type test func --- packages/nodejs/src/vat/streams.test.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/nodejs/src/vat/streams.test.ts b/packages/nodejs/src/vat/streams.test.ts index bf9668b15..00a263387 100644 --- a/packages/nodejs/src/vat/streams.test.ts +++ b/packages/nodejs/src/vat/streams.test.ts @@ -2,8 +2,7 @@ import '@ocap/test-utils/mock-endoify'; import { describe, expect, it, vi } from 'vitest'; -// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -const doMockParentPort = (value: unknown) => { +const doMockParentPort = (value: unknown): void => { vi.doMock('node:worker_threads', () => ({ parentPort: value, })); From 73dc899b2f6ee0e4075b5800ea49f3e52ee7ef66 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:15:59 -0600 Subject: [PATCH 20/55] appease linter --- eslint.config.mjs | 9 ++++++++- .../test/workers/{stream-sync.mjs => stream-sync.js} | 0 vitest.config.ts | 2 +- 3 files changed, 9 insertions(+), 2 deletions(-) rename packages/nodejs/test/workers/{stream-sync.mjs => stream-sync.js} (100%) diff --git a/eslint.config.mjs b/eslint.config.mjs index ebddd69cf..bb98851c3 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -183,13 +183,20 @@ const config = createConfig([ { files: [ 'packages/nodejs/**/*-worker.ts', - 'packages/nodejs/test/workers/**/*.mjs', + 'packages/nodejs/test/workers/**/*.js', ], rules: { // Node workers have reasonable cause to read from process.env 'n/no-process-env': 'off', }, }, + { + files: ['packages/nodejs/test/workers/**/*.js'], + rules: { + // Test node worker files can resolve these imports, even if eslint cannot. + 'import-x/no-unresolved': 'off', + }, + }, ]); export default config; diff --git a/packages/nodejs/test/workers/stream-sync.mjs b/packages/nodejs/test/workers/stream-sync.js similarity index 100% rename from packages/nodejs/test/workers/stream-sync.mjs rename to packages/nodejs/test/workers/stream-sync.js diff --git a/vitest.config.ts b/vitest.config.ts index 7dadad60e..7f900b917 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -112,4 +112,4 @@ export default defineConfig({ }, }, }, -}); \ No newline at end of file +}); From 2b33bafe794542a1a5fd04ac9ea4a7aea3e75962 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:29:05 -0600 Subject: [PATCH 21/55] update extensions --- eslint.config.mjs | 4 ++-- packages/nodejs/test/workers/index.ts | 2 +- vitest.config.ts | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/eslint.config.mjs b/eslint.config.mjs index bb98851c3..99fc4818c 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -183,7 +183,7 @@ const config = createConfig([ { files: [ 'packages/nodejs/**/*-worker.ts', - 'packages/nodejs/test/workers/**/*.js', + 'packages/nodejs/test/workers/**/*', ], rules: { // Node workers have reasonable cause to read from process.env @@ -191,7 +191,7 @@ const config = createConfig([ }, }, { - files: ['packages/nodejs/test/workers/**/*.js'], + files: ['packages/nodejs/test/workers/**/*'], rules: { // Test node worker files can resolve these imports, even if eslint cannot. 'import-x/no-unresolved': 'off', diff --git a/packages/nodejs/test/workers/index.ts b/packages/nodejs/test/workers/index.ts index 60c82437b..0fd6a4a00 100644 --- a/packages/nodejs/test/workers/index.ts +++ b/packages/nodejs/test/workers/index.ts @@ -1,2 +1,2 @@ export const getTestWorkerFile = (name: string): string => - new URL(`./${name}.mjs`, import.meta.url).pathname; + new URL(`./${name}.js`, import.meta.url).pathname; diff --git a/vitest.config.ts b/vitest.config.ts index 7f900b917..167566484 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -81,8 +81,8 @@ export default defineConfig({ }, 'packages/nodejs/**': { statements: 47.61, - functions: 47.36, - branches: 27.77, + functions: 47.61, + branches: 35.29, lines: 47.61, }, 'packages/shims/**': { From 90c0d2a5089aeef780f346d8a64d717f2ee6d590 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:32:10 -0600 Subject: [PATCH 22/55] thresholds --- vitest.config.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vitest.config.ts b/vitest.config.ts index 167566484..bbc9c69ad 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -74,16 +74,16 @@ export default defineConfig({ lines: 68.73, }, 'packages/kernel/**': { - statements: 44.12, + statements: 43.97, functions: 55.55, branches: 30.03, - lines: 44.35, + lines: 44.2, }, 'packages/nodejs/**': { - statements: 47.61, + statements: 46.75, functions: 47.61, branches: 35.29, - lines: 47.61, + lines: 46.75, }, 'packages/shims/**': { statements: 0, From 82bb2bd94c4ada14ed9e8ca73c7ea11b1550b77f Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 15:48:48 -0600 Subject: [PATCH 23/55] simplify test a bit --- packages/nodejs/test/e2e/kernel-worker.test.ts | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 7fc07dc1e..9b3ce8226 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -54,28 +54,23 @@ describe('Kernel Worker', () => { await Promise.all( testVatIds.map(async () => await kernel.launchVat(testVatConfig)), ); + expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); }; it('restarts vats', async () => { await launchTestVats(); - expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - await Promise.all(testVatIds.map(kernel.restartVat.bind(kernel))); expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); }); it('terminates all vats', async () => { await launchTestVats(); - expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - await kernel.terminateAllVats(); expect(kernel.getVatIds()).toHaveLength(0); }); it('pings vats', async () => { await launchTestVats(); - expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - await Promise.all( testVatIds.map( async (vatId: VatId) => From d760a69df397ae6b9439e6264c26025aadc33a96 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 24 Jan 2025 16:04:29 -0600 Subject: [PATCH 24/55] isolate CI failure --- .../src/kernel/VatWorkerService.test.ts | 29 ++++++++------- .../nodejs/src/kernel/VatWorkerService.ts | 1 + packages/nodejs/src/vat/streams.test.ts | 6 +-- .../nodejs/test/e2e/kernel-worker.test.ts | 2 +- packages/nodejs/test/e2e/vat-worker.test.ts | 37 +++++++++++++++++++ packages/nodejs/test/workers/hello-world.js | 2 + packages/nodejs/tsconfig.json | 3 +- vitest.config.ts | 6 +-- 8 files changed, 65 insertions(+), 21 deletions(-) create mode 100644 packages/nodejs/test/e2e/vat-worker.test.ts create mode 100644 packages/nodejs/test/workers/hello-world.js diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index b53b77f04..58e35ec97 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -19,17 +19,20 @@ describe('NodejsVatWorkerService', () => { const getTestVatId = (): VatId => `v${vatIdCounter()}`; describe('launch', () => { - it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { - const service = new NodejsVatWorkerService({ - workerFilePath: testWorkerFile, - }); - const testVatId: VatId = getTestVatId(); - const stream = await service.launch(testVatId); - - expect(stream).toBeInstanceOf(NodeWorkerDuplexStream); - }); - - it('rejects if synchronize fails', async () => { + it.todo( + 'creates a NodeWorker and returns a NodeWorkerDuplexStream', + async () => { + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); + const testVatId: VatId = getTestVatId(); + const stream = await service.launch(testVatId); + + expect(stream).toBeInstanceOf(NodeWorkerDuplexStream); + }, + ); + + it.todo('rejects if synchronize fails', async () => { const rejected = 'test-reject-value'; vi.doMock('@ocap/streams', () => ({ @@ -49,7 +52,7 @@ describe('NodejsVatWorkerService', () => { }); }); - describe('terminate', () => { + describe.todo('terminate', () => { it('terminates the target vat', async () => { const service = new NodejsVatWorkerService({ workerFilePath: testWorkerFile, @@ -75,7 +78,7 @@ describe('NodejsVatWorkerService', () => { }); }); - describe('terminateAll', () => { + describe.todo('terminateAll', () => { it('terminates all vats', async () => { const service = new NodejsVatWorkerService({ workerFilePath: testWorkerFile, diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 6ddcecc7c..99d147d33 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -56,6 +56,7 @@ export class NodejsVatWorkerService implements VatWorkerService { NODE_VAT_ID: vatId, }, }); + worker.stdout.pipe(process.stdout); worker.once('online', () => { const stream = new NodeWorkerDuplexStream( worker, diff --git a/packages/nodejs/src/vat/streams.test.ts b/packages/nodejs/src/vat/streams.test.ts index 00a263387..cb1c642de 100644 --- a/packages/nodejs/src/vat/streams.test.ts +++ b/packages/nodejs/src/vat/streams.test.ts @@ -9,9 +9,9 @@ const doMockParentPort = (value: unknown): void => { vi.resetModules(); }; -vi.mock('@ocap/kernel', async () => { - return { isVatCommand: vi.fn(() => true) }; -}); +vi.mock('@ocap/kernel', async () => ({ + isVatCommand: vi.fn(() => true), +})); vi.mock('@ocap/streams', () => ({ NodeWorkerDuplexStream: vi.fn(), diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 9b3ce8226..2febd10d1 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -61,7 +61,7 @@ describe('Kernel Worker', () => { await launchTestVats(); await Promise.all(testVatIds.map(kernel.restartVat.bind(kernel))); expect(kernel.getVatIds().sort()).toStrictEqual(testVatIds); - }); + }, 5000); it('terminates all vats', async () => { await launchTestVats(); diff --git a/packages/nodejs/test/e2e/vat-worker.test.ts b/packages/nodejs/test/e2e/vat-worker.test.ts new file mode 100644 index 000000000..40f50162e --- /dev/null +++ b/packages/nodejs/test/e2e/vat-worker.test.ts @@ -0,0 +1,37 @@ +import '@ocap/shims/endoify'; + +import type { VatId } from '@ocap/kernel'; +import { makePromiseKitMock } from '@ocap/test-utils'; +import { makeCounter } from '@ocap/utils'; +import { describe, expect, it } from 'vitest'; +import { Worker as NodeWorker } from 'worker_threads'; + +import { getTestWorkerFile } from '../workers'; + +const { makePromiseKit } = makePromiseKitMock(); + +describe('NodejsVatWorkerService', () => { + let testWorkerFile: string; + const vatIdCounter = makeCounter(); + const getTestVatId = (): VatId => `v${vatIdCounter()}`; + + describe('hello-world', () => { + testWorkerFile = getTestWorkerFile('hello-world'); + it('can start in a Node.js worker', async () => { + const vatId = getTestVatId(); + const worker = new NodeWorker(testWorkerFile, { + env: { + NODE_VAT_ID: vatId, + }, + }); + const { resolve, reject, promise } = makePromiseKit(); + worker.once('online', (error: Error) => { + if (error) { + reject(error); + } + resolve(vatId); + }); + expect(await promise).toStrictEqual(vatId); + }); + }); +}); diff --git a/packages/nodejs/test/workers/hello-world.js b/packages/nodejs/test/workers/hello-world.js new file mode 100644 index 000000000..216a0d654 --- /dev/null +++ b/packages/nodejs/test/workers/hello-world.js @@ -0,0 +1,2 @@ +console.debug('hello world computer', process.env.NODE_VAT_ID); +export {}; diff --git a/packages/nodejs/tsconfig.json b/packages/nodejs/tsconfig.json index 0490ddc26..74ba30066 100644 --- a/packages/nodejs/tsconfig.json +++ b/packages/nodejs/tsconfig.json @@ -23,6 +23,7 @@ "./test/**/*.ts", "./vitest.config.ts", "./vitest.config.e2e.ts", - "../../types" + "../../types", + "./test/workers/*.js" ] } diff --git a/vitest.config.ts b/vitest.config.ts index bbc9c69ad..6ac1bf107 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -80,10 +80,10 @@ export default defineConfig({ lines: 44.2, }, 'packages/nodejs/**': { - statements: 46.75, - functions: 47.61, + statements: 19.23, + functions: 19.04, branches: 35.29, - lines: 46.75, + lines: 19.23, }, 'packages/shims/**': { statements: 0, From a5b9154434cdcd0363ba272054ace60f11f32c68 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 27 Jan 2025 13:56:41 -0600 Subject: [PATCH 25/55] test(nodejs): reallocate coverage between unit and e2e phases --- .../src/kernel/VatWorkerService.test.ts | 71 ++++++++------- .../nodejs/src/kernel/VatWorkerService.ts | 1 - .../nodejs/test/e2e/VatWorkerService.test.ts | 91 +++++++++++++++++++ 3 files changed, 130 insertions(+), 33 deletions(-) create mode 100644 packages/nodejs/test/e2e/VatWorkerService.test.ts diff --git a/packages/nodejs/src/kernel/VatWorkerService.test.ts b/packages/nodejs/src/kernel/VatWorkerService.test.ts index 58e35ec97..e786b5855 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.test.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.test.ts @@ -1,12 +1,31 @@ import '@ocap/shims/endoify'; import type { VatId } from '@ocap/kernel'; -import { NodeWorkerDuplexStream } from '@ocap/streams'; import { makeCounter } from '@ocap/utils'; import { describe, expect, it, vi } from 'vitest'; import { NodejsVatWorkerService } from './VatWorkerService.js'; -import { getTestWorkerFile } from '../../test/workers'; + +const mocks = vi.hoisted(() => ({ + worker: { + once: (_: string, callback: () => unknown) => { + callback(); + }, + terminate: vi.fn(async () => undefined), + }, + stream: { + synchronize: vi.fn(async () => undefined).mockResolvedValue(undefined), + return: vi.fn(async () => ({})), + }, +})); + +vi.mock('@ocap/streams', () => ({ + NodeWorkerDuplexStream: vi.fn(() => mocks.stream), +})); + +vi.mock('node:worker_threads', () => ({ + Worker: vi.fn(() => mocks.worker), +})); describe('NodejsVatWorkerService', () => { it('constructs an instance without any arguments', () => { @@ -14,37 +33,25 @@ describe('NodejsVatWorkerService', () => { expect(instance).toBeInstanceOf(NodejsVatWorkerService); }); - const testWorkerFile = getTestWorkerFile('stream-sync'); + const workerFilePath = 'unused'; const vatIdCounter = makeCounter(); const getTestVatId = (): VatId => `v${vatIdCounter()}`; describe('launch', () => { - it.todo( - 'creates a NodeWorker and returns a NodeWorkerDuplexStream', - async () => { - const service = new NodejsVatWorkerService({ - workerFilePath: testWorkerFile, - }); - const testVatId: VatId = getTestVatId(); - const stream = await service.launch(testVatId); - - expect(stream).toBeInstanceOf(NodeWorkerDuplexStream); - }, - ); - - it.todo('rejects if synchronize fails', async () => { - const rejected = 'test-reject-value'; + it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { + const service = new NodejsVatWorkerService({ + workerFilePath, + }); + const testVatId: VatId = getTestVatId(); + const stream = await service.launch(testVatId); - vi.doMock('@ocap/streams', () => ({ - NodeWorkerDuplexStream: vi.fn().mockImplementation(() => ({ - synchronize: vi.fn().mockRejectedValue(rejected), - })), - })); - vi.resetModules(); - const NVWS = (await import('./VatWorkerService.js')) - .NodejsVatWorkerService; + expect(stream).toStrictEqual(mocks.stream); + }); - const service = new NVWS({ workerFilePath: testWorkerFile }); + it('rejects if synchronize fails', async () => { + const rejected = 'test-reject-value'; + mocks.stream.synchronize.mockRejectedValue(rejected); + const service = new NodejsVatWorkerService({ workerFilePath }); const testVatId: VatId = getTestVatId(); await expect(async () => await service.launch(testVatId)).rejects.toThrow( rejected, @@ -52,10 +59,10 @@ describe('NodejsVatWorkerService', () => { }); }); - describe.todo('terminate', () => { + describe('terminate', () => { it('terminates the target vat', async () => { const service = new NodejsVatWorkerService({ - workerFilePath: testWorkerFile, + workerFilePath, }); const testVatId: VatId = getTestVatId(); @@ -68,7 +75,7 @@ describe('NodejsVatWorkerService', () => { it('throws when terminating an unknown vat', async () => { const service = new NodejsVatWorkerService({ - workerFilePath: testWorkerFile, + workerFilePath, }); const testVatId: VatId = getTestVatId(); @@ -78,10 +85,10 @@ describe('NodejsVatWorkerService', () => { }); }); - describe.todo('terminateAll', () => { + describe('terminateAll', () => { it('terminates all vats', async () => { const service = new NodejsVatWorkerService({ - workerFilePath: testWorkerFile, + workerFilePath, }); const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 99d147d33..6ddcecc7c 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -56,7 +56,6 @@ export class NodejsVatWorkerService implements VatWorkerService { NODE_VAT_ID: vatId, }, }); - worker.stdout.pipe(process.stdout); worker.once('online', () => { const stream = new NodeWorkerDuplexStream( worker, diff --git a/packages/nodejs/test/e2e/VatWorkerService.test.ts b/packages/nodejs/test/e2e/VatWorkerService.test.ts new file mode 100644 index 000000000..e776c8f77 --- /dev/null +++ b/packages/nodejs/test/e2e/VatWorkerService.test.ts @@ -0,0 +1,91 @@ +import '@ocap/shims/endoify'; + +import type { VatId } from '@ocap/kernel'; +import { NodeWorkerDuplexStream } from '@ocap/streams'; +import { makeCounter } from '@ocap/utils'; +import { describe, expect, it, vi } from 'vitest'; + +import { NodejsVatWorkerService } from '../../src/kernel/VatWorkerService.js'; +import { getTestWorkerFile } from '../workers'; + +describe('NodejsVatWorkerService', () => { + const testWorkerFile = getTestWorkerFile('stream-sync'); + const vatIdCounter = makeCounter(); + const getTestVatId = (): VatId => `v${vatIdCounter()}`; + + describe('launch', () => { + it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => { + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); + const testVatId: VatId = getTestVatId(); + const stream = await service.launch(testVatId); + + expect(stream).toBeInstanceOf(NodeWorkerDuplexStream); + }); + + it('rejects if synchronize fails', async () => { + const rejected = 'test-reject-value'; + + vi.doMock('@ocap/streams', () => ({ + NodeWorkerDuplexStream: vi.fn().mockImplementation(() => ({ + synchronize: vi.fn(() => 'no').mockRejectedValue(rejected), + })), + })); + vi.resetModules(); + const NVWS = (await import('../../src/kernel/VatWorkerService.js')) + .NodejsVatWorkerService; + + const service = new NVWS({ workerFilePath: testWorkerFile }); + const testVatId: VatId = getTestVatId(); + await expect(async () => await service.launch(testVatId)).rejects.toThrow( + rejected, + ); + }); + }); + + describe('terminate', () => { + it('terminates the target vat', async () => { + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); + const testVatId: VatId = getTestVatId(); + + await service.launch(testVatId); + expect(service.workers.has(testVatId)).toBe(true); + + await service.terminate(testVatId); + expect(service.workers.has(testVatId)).toBe(false); + }); + + it('throws when terminating an unknown vat', async () => { + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); + const testVatId: VatId = getTestVatId(); + + await expect( + async () => await service.terminate(testVatId), + ).rejects.toThrow(/No worker found/u); + }); + }); + + describe('terminateAll', () => { + it('terminates all vats', async () => { + const service = new NodejsVatWorkerService({ + workerFilePath: testWorkerFile, + }); + const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()]; + + await Promise.all( + vatIds.map(async (vatId) => await service.launch(vatId)), + ); + + expect(Array.from(service.workers.values())).toHaveLength(vatIds.length); + + await service.terminateAll(); + + expect(Array.from(service.workers.values())).toHaveLength(0); + }); + }); +}); From 7fc4b8ee28a24812aba943aa5cb17103df98fa4c Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 27 Jan 2025 14:05:27 -0600 Subject: [PATCH 26/55] thresholds --- vitest.config.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vitest.config.ts b/vitest.config.ts index 6ac1bf107..bbc9c69ad 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -80,10 +80,10 @@ export default defineConfig({ lines: 44.2, }, 'packages/nodejs/**': { - statements: 19.23, - functions: 19.04, + statements: 46.75, + functions: 47.61, branches: 35.29, - lines: 19.23, + lines: 46.75, }, 'packages/shims/**': { statements: 0, From dfe16eadb5e25b1d79c7976896cbf4a8a5b570fa Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 27 Jan 2025 16:50:08 -0600 Subject: [PATCH 27/55] feat(nodejs): Add an ollama vat --- packages/nodejs/package.json | 2 ++ packages/nodejs/src/vats/ollama.js | 35 ++++++++++++++++++++++++++++++ yarn.lock | 18 +++++++++++++++ 3 files changed, 55 insertions(+) create mode 100644 packages/nodejs/src/vats/ollama.js diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 48d130ce1..a32ab354b 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -77,12 +77,14 @@ "node": "^20 || >=22" }, "dependencies": { + "@endo/marshal": "^1.6.2", "@endo/promise-kit": "^1.1.6", "@ocap/kernel": "workspace:^", "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", "better-sqlite3": "^11.7.2", + "ollama": "^0.5.12", "ses": "^1.9.0" } } diff --git a/packages/nodejs/src/vats/ollama.js b/packages/nodejs/src/vats/ollama.js new file mode 100644 index 000000000..dc98a584b --- /dev/null +++ b/packages/nodejs/src/vats/ollama.js @@ -0,0 +1,35 @@ +import { Far } from '@endo/marshal'; +import ollama from 'ollama'; + +// The default LLM model to use. +const DEFAULT_MODEL = 'deepseek-r1:1.5b'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(_vatPowers, parameters, _baggage) { + const model = parameters?.model ?? DEFAULT_MODEL; + console.log(`[LLM] buildRootObject "${model}"`); + + return Far('root', { + async bootstrap() { + await ollama.pull({ + model, + }); + }, + async chat(prompt) { + const response = await ollama.chat({ + model, + messages: [{ role: 'user', content: prompt }], + }); + const { content } = response.message; + console.log(content); + return content; + }, + }); +} diff --git a/yarn.lock b/yarn.lock index b0de7f3da..cdf354b35 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2292,6 +2292,7 @@ __metadata: resolution: "@ocap/nodejs@workspace:packages/nodejs" dependencies: "@arethetypeswrong/cli": "npm:^0.17.3" + "@endo/marshal": "npm:^1.6.2" "@endo/promise-kit": "npm:^1.1.6" "@metamask/auto-changelog": "npm:^4.0.0" "@metamask/eslint-config": "npm:^14.0.0" @@ -2321,6 +2322,7 @@ __metadata: eslint-plugin-prettier: "npm:^5.2.1" eslint-plugin-promise: "npm:^7.1.0" node-gyp: "npm:^11.0.0" + ollama: "npm:^0.5.12" prettier: "npm:^3.3.3" rimraf: "npm:^6.0.1" ses: "npm:^1.9.0" @@ -9080,6 +9082,15 @@ __metadata: languageName: node linkType: hard +"ollama@npm:^0.5.12": + version: 0.5.12 + resolution: "ollama@npm:0.5.12" + dependencies: + whatwg-fetch: "npm:^3.6.20" + checksum: 10/90636b7f1c68ed1e0e992e33da4320536db61b002b036d809d8bed417d5c604e174c9bc4311562e8438c67f9dadf6550c4b76cd5a869a102db66542c43b16727 + languageName: node + linkType: hard + "once@npm:^1.3.0, once@npm:^1.3.1, once@npm:^1.4.0": version: 1.4.0 resolution: "once@npm:1.4.0" @@ -12073,6 +12084,13 @@ __metadata: languageName: node linkType: hard +"whatwg-fetch@npm:^3.6.20": + version: 3.6.20 + resolution: "whatwg-fetch@npm:3.6.20" + checksum: 10/2b4ed92acd6a7ad4f626a6cb18b14ec982bbcaf1093e6fe903b131a9c6decd14d7f9c9ca3532663c2759d1bdf01d004c77a0adfb2716a5105465c20755a8c57c + languageName: node + linkType: hard + "whatwg-mimetype@npm:^4.0.0": version: 4.0.0 resolution: "whatwg-mimetype@npm:4.0.0" From 855660703022b150516eaca1febe9017abb11497 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 29 Jan 2025 09:48:40 -0600 Subject: [PATCH 28/55] draft --- .../src/{vats/ollama.js => vat/ollama.txt} | 0 packages/nodejs/src/vats/data.json | 3 ++ packages/nodejs/src/vats/readFile.js | 30 +++++++++++++++++++ 3 files changed, 33 insertions(+) rename packages/nodejs/src/{vats/ollama.js => vat/ollama.txt} (100%) create mode 100644 packages/nodejs/src/vats/data.json create mode 100644 packages/nodejs/src/vats/readFile.js diff --git a/packages/nodejs/src/vats/ollama.js b/packages/nodejs/src/vat/ollama.txt similarity index 100% rename from packages/nodejs/src/vats/ollama.js rename to packages/nodejs/src/vat/ollama.txt diff --git a/packages/nodejs/src/vats/data.json b/packages/nodejs/src/vats/data.json new file mode 100644 index 000000000..f31aaff52 --- /dev/null +++ b/packages/nodejs/src/vats/data.json @@ -0,0 +1,3 @@ +{ + "data": ["hello", "world", "computer"] +} \ No newline at end of file diff --git a/packages/nodejs/src/vats/readFile.js b/packages/nodejs/src/vats/readFile.js new file mode 100644 index 000000000..318a48647 --- /dev/null +++ b/packages/nodejs/src/vats/readFile.js @@ -0,0 +1,30 @@ +import * as fs from 'node:fs'; +import { Far } from '@endo/marshal'; + +// The filepath to read. +const DEFAULT_FILEPATH = './data.json'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(_vatPowers, parameters, _baggage) { + const filepath = parameters?.filepath ?? DEFAULT_FILEPATH; + console.log(`buildRootObject "${filepath}"`); + + return Far('root', { + async bootstrap() { + console.log(`bootstrap readFile: ${filepath}`); + }, + read() { + const content = fs.readFileSync(__dirname + '/file.txt'); + console.log(content); + return content; + }, + }); +} + From 598e3976eb2a859f8e35ea27daba22e90f40b272 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 30 Jan 2025 12:20:43 -0600 Subject: [PATCH 29/55] latest draft --- .../src/{vats => bundle-example}/data.json | 2 +- .../nodejs/src/bundle-example/doBundle.mjs | 17 +++++++++++ packages/nodejs/src/bundle-example/lib.mjs | 23 ++++++++++++++ packages/nodejs/src/bundle-example/vat.bundle | 1 + packages/nodejs/src/bundle-example/vat.js | 26 ++++++++++++++++ packages/nodejs/src/vats/ollama.bundle | 1 + .../src/{vat/ollama.txt => vats/ollama.js} | 18 ++++++----- packages/nodejs/src/vats/readFile.js | 30 ------------------- .../nodejs/test/e2e/kernel-worker.test.ts | 24 +++++++++++++++ 9 files changed, 104 insertions(+), 38 deletions(-) rename packages/nodejs/src/{vats => bundle-example}/data.json (95%) create mode 100644 packages/nodejs/src/bundle-example/doBundle.mjs create mode 100644 packages/nodejs/src/bundle-example/lib.mjs create mode 100644 packages/nodejs/src/bundle-example/vat.bundle create mode 100644 packages/nodejs/src/bundle-example/vat.js create mode 100644 packages/nodejs/src/vats/ollama.bundle rename packages/nodejs/src/{vat/ollama.txt => vats/ollama.js} (72%) delete mode 100644 packages/nodejs/src/vats/readFile.js diff --git a/packages/nodejs/src/vats/data.json b/packages/nodejs/src/bundle-example/data.json similarity index 95% rename from packages/nodejs/src/vats/data.json rename to packages/nodejs/src/bundle-example/data.json index f31aaff52..9849b6506 100644 --- a/packages/nodejs/src/vats/data.json +++ b/packages/nodejs/src/bundle-example/data.json @@ -1,3 +1,3 @@ { "data": ["hello", "world", "computer"] -} \ No newline at end of file +} diff --git a/packages/nodejs/src/bundle-example/doBundle.mjs b/packages/nodejs/src/bundle-example/doBundle.mjs new file mode 100644 index 000000000..9ac104d9d --- /dev/null +++ b/packages/nodejs/src/bundle-example/doBundle.mjs @@ -0,0 +1,17 @@ +import '@ocap/shims/endoify'; +import bundleSource from '@endo/bundle-source'; +import { resolve } from './lib.mjs'; +import { writeFile } from 'fs/promises'; + +main( + resolve('vat.js'), + resolve('vat.bundle'), +).catch(console.error); + +async function main(source, target) { + console.log('bundleSource', bundleSource); + const bundle = await bundleSource(source); + const bundleString = JSON.stringify(bundle); + await writeFile(target, bundleString); + console.log(`wrote ${target}: ${new Blob([bundleString]).size} bytes`); +} diff --git a/packages/nodejs/src/bundle-example/lib.mjs b/packages/nodejs/src/bundle-example/lib.mjs new file mode 100644 index 000000000..4029f3599 --- /dev/null +++ b/packages/nodejs/src/bundle-example/lib.mjs @@ -0,0 +1,23 @@ +const { promises } = await import('fs'); +const url = await import('url'); + +/** + * Resolve a path given relative to this file. + * + * @param {string} relativePath - The path to load, relative to this file. + * @returns An absolute filepath. + */ +export function resolve(relativePath) { + return url.fileURLToPath(new URL(relativePath, import.meta.url)); +}; + +/** + * Load the content from the file at the given filepath. + * + * @param {string} relativePath - The path to load, relative to this file. + * @returns The data stored in filepath. + */ +export async function getContent(relativePath) { + const rawContent = await promises.readFile(resolve(relativePath)); + return rawContent.toString(); +} diff --git a/packages/nodejs/src/bundle-example/vat.bundle b/packages/nodejs/src/bundle-example/vat.bundle new file mode 100644 index 000000000..50e26f8ca --- /dev/null +++ b/packages/nodejs/src/bundle-example/vat.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"87c9ac097da785a31633b0728073f2f837c6807b9a086923f20382261f19c1c5428b050b2545c004695f3fe90664b3bfd5d08ba7483f145593a2b29be1ad8504"} \ No newline at end of file diff --git a/packages/nodejs/src/bundle-example/vat.js b/packages/nodejs/src/bundle-example/vat.js new file mode 100644 index 000000000..bcec0c479 --- /dev/null +++ b/packages/nodejs/src/bundle-example/vat.js @@ -0,0 +1,26 @@ +import { Far } from '@endo/marshal'; +import { getContent } from './lib.mjs'; + +/** + * Build function for the vat. + * + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(parameters) { + const filepath = parameters?.filepath ?? 'data.json'; + console.log('buildRootObject', filepath); + + let content; + + return Far('root', { + async bootstrap() { + content = await getContent(filepath); + console.log('bootstrap', filepath); + }, + read() { + console.log(content); + return content; + }, + }); +} diff --git a/packages/nodejs/src/vats/ollama.bundle b/packages/nodejs/src/vats/ollama.bundle new file mode 100644 index 000000000..d54af7e03 --- /dev/null +++ b/packages/nodejs/src/vats/ollama.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"88cd3fa179b5cbc4b734185d8b61aa20b1e02a17a1567b555e28af8ba37b81239a6e5500e78d6eb1823439eb9542c3b497f3dac773602d1eb2e363f6d4936fbe"} \ No newline at end of file diff --git a/packages/nodejs/src/vat/ollama.txt b/packages/nodejs/src/vats/ollama.js similarity index 72% rename from packages/nodejs/src/vat/ollama.txt rename to packages/nodejs/src/vats/ollama.js index dc98a584b..448f8844b 100644 --- a/packages/nodejs/src/vat/ollama.txt +++ b/packages/nodejs/src/vats/ollama.js @@ -1,5 +1,4 @@ import { Far } from '@endo/marshal'; -import ollama from 'ollama'; // The default LLM model to use. const DEFAULT_MODEL = 'deepseek-r1:1.5b'; @@ -16,19 +15,24 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { const model = parameters?.model ?? DEFAULT_MODEL; console.log(`[LLM] buildRootObject "${model}"`); + let content; + + const prompt = parameters?.prompt ?? `Say hello, ${model}.`; + return Far('root', { - async bootstrap() { + async bootstrap(vats) { + console.log('bootstrap', { model, prompt }); + const ollama = (await import('ollama')).default; await ollama.pull({ model, }); - }, - async chat(prompt) { const response = await ollama.chat({ model, - messages: [{ role: 'user', content: prompt }], + messages: [{ role: 'admin', content: prompt }], }); - const { content } = response.message; - console.log(content); + content = response.message; + }, + async chat() { return content; }, }); diff --git a/packages/nodejs/src/vats/readFile.js b/packages/nodejs/src/vats/readFile.js deleted file mode 100644 index 318a48647..000000000 --- a/packages/nodejs/src/vats/readFile.js +++ /dev/null @@ -1,30 +0,0 @@ -import * as fs from 'node:fs'; -import { Far } from '@endo/marshal'; - -// The filepath to read. -const DEFAULT_FILEPATH = './data.json'; - -/** - * Build function for the LLM test vat. - * - * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). - * @param {unknown} parameters - Initialization parameters from the vat's config object. - * @param {unknown} _baggage - Root of vat's persistent state (not used here). - * @returns {unknown} The root object for the new vat. - */ -export function buildRootObject(_vatPowers, parameters, _baggage) { - const filepath = parameters?.filepath ?? DEFAULT_FILEPATH; - console.log(`buildRootObject "${filepath}"`); - - return Far('root', { - async bootstrap() { - console.log(`bootstrap readFile: ${filepath}`); - }, - read() { - const content = fs.readFileSync(__dirname + '/file.txt'); - console.log(content); - return content; - }, - }); -} - diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 2febd10d1..4e085473e 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -43,6 +43,29 @@ describe('Kernel Worker', () => { } }); + it('hosts an LLM', async () => { + const model = 'deepseek-r1:1.5b'; + const ollamaVatConfig: VatConfig = { + bundleSpec: 'http://localhost:3000/ollama.bundle', + parameters: { + model, + prompt: [ + `You are an instance of LLM model ${model}.`, + 'A user has asked you to give an introduction.', + 'Say hello and show what you can do!', + ].join(' '), + }, + }; + await kernel.launchSubcluster({ + bootstrap: 'ollama', + vats: { + ollama: ollamaVatConfig, + }, + }); + expect(true).toBe(true); + }); + + /* it('launches a vat', async () => { expect(kernel.getVatIds()).toHaveLength(0); const kRef = await kernel.launchVat(testVatConfig); @@ -82,4 +105,5 @@ describe('Kernel Worker', () => { ); expect(true).toBe(true); }); + */ }); From 05df1c31397b27f811113c1cb61dbc338d1ff03c Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 30 Jan 2025 18:49:38 -0600 Subject: [PATCH 30/55] add ollama script and fix vats --- packages/kernel/package.json | 1 + packages/kernel/src/Kernel.ts | 8 ++-- packages/kernel/src/VatSupervisor.ts | 37 ++++++++++++++- packages/nodejs/scripts/call-ollama.js | 46 +++++++++++++++++++ packages/nodejs/src/kernel/make-kernel.ts | 4 +- packages/nodejs/src/kernel/sqlite-kv-store.ts | 11 ++--- packages/nodejs/src/vats/ollama.bundle | 2 +- packages/nodejs/src/vats/ollama.js | 32 ++++++------- .../nodejs/test/e2e/kernel-worker.test.ts | 8 +++- yarn.lock | 1 + 10 files changed, 120 insertions(+), 30 deletions(-) create mode 100644 packages/nodejs/scripts/call-ollama.js diff --git a/packages/kernel/package.json b/packages/kernel/package.json index b07a41c1d..c04392528 100644 --- a/packages/kernel/package.json +++ b/packages/kernel/package.json @@ -58,6 +58,7 @@ "@ocap/errors": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", + "ollama": "^0.5.12", "ses": "^1.9.0", "setimmediate": "^1.0.5" }, diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 0ae10ad24..8cd2e5904 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -474,10 +474,12 @@ export class Kernel { if (vatId) { const vat = this.#getVat(vatId); if (vat) { - if (typeof message.result !== 'string') { - throw TypeError('message result must be a string'); + if (message.result) { + if (typeof message.result !== 'string') { + throw TypeError('message result must be a string'); + } + this.#storage.setPromiseDecider(message.result, vatId); } - this.#storage.setPromiseDecider(message.result, vatId); const vatTarget = this.#translateRefKtoV(vatId, target, false); const vatMessage = this.#translateMessageKtoV(vatId, message); await vat.deliverMessage(vatTarget, vatMessage); diff --git a/packages/kernel/src/VatSupervisor.ts b/packages/kernel/src/VatSupervisor.ts index 712c57823..46170d89a 100644 --- a/packages/kernel/src/VatSupervisor.ts +++ b/packages/kernel/src/VatSupervisor.ts @@ -23,6 +23,8 @@ import type { VatConfig, VRef } from './types.js'; import { ROOT_OBJECT_VREF, isVatConfig } from './types.js'; import { waitUntilQuiescent } from './waitUntilQuiescent.js'; +import { Ollama } from 'ollama'; + const makeLiveSlots: MakeLiveSlotsFn = localMakeLiveSlots; type SupervisorConstructorProps = { @@ -201,7 +203,40 @@ export class VatSupervisor { const kvStore = await this.#makeKVStore(`[vat-${this.id}]`, true); const syscall = makeSupervisorSyscall(this, kvStore); - const vatPowers = {}; // XXX should be something more real + + // XXX We pull the model in the VatSupervisor. This is definitely not how this should be done, + // perhaps not even in this proof of concept. + const DEFAULT_MODEL = 'deepseek-r1:1.5b'; + const ollama = new Ollama({ + host: 'http://localhost:11434', + }); + + const ollamaPull = async (model: string) => { + console.log(`downloading ${model}...`) + let currentDigestDone = false + const stream = await ollama.pull({ model: model, stream: true }) + for await (const part of stream) { + if (part.digest) { + let percent = 0 + if (part.completed && part.total) { + percent = Math.round((part.completed / part.total) * 100) + } + process.stdout.write(`${part.status} ${percent}%...`) // Write the new text + if (percent === 100 && !currentDigestDone) { + console.log() // Output to a new line + currentDigestDone = true + } else { + currentDigestDone = false + } + } else { + console.log(part.status) + } + } + } + + await ollamaPull(DEFAULT_MODEL).catch(console.error); + + const vatPowers = { chat: ollama.chat.bind(ollama) }; // XXX should be something more real const liveSlotsOptions = {}; // XXX should be something more real const gcTools: GCTools = harden({ diff --git a/packages/nodejs/scripts/call-ollama.js b/packages/nodejs/scripts/call-ollama.js new file mode 100644 index 000000000..05c3180d5 --- /dev/null +++ b/packages/nodejs/scripts/call-ollama.js @@ -0,0 +1,46 @@ +import ollama from 'ollama'; + +/** + * The main function for the script. + * + * @param {*} param0 - An arguments bag. + * @param { string } param0.model - The model to pull and use. + * @param { string } param0.prompt - The prompt to give the model. + */ +async function main({ model, prompt }) { + if (!prompt) { + throw new Error('say something'); + } + + console.log('OLLAMA', 'pull'); + + await ollama.pull({ model }); + + console.log('USER:', prompt); + process.stdout.write('OLLAMA: '); + + const response = await ollama.chat({ + model, // Specify the model you want to use + messages: [ + { role: 'admin', content: [ + `You are an instance of LLM model ${model}.`, + `Respond to user requests ${'respectfully'} and ${'informatively'}.`, + ].join(' ')}, + { role: 'user', content: prompt } + ], // The message to send + stream: true // Enable streaming + }); + + let accumulatedContent = ''; + for await (const part of response) { + accumulatedContent += part.message.content; + process.stdout.write(part.message.content); // Write each part of the response to the console + } + console.log('\n'); // Add a newline after the streaming response +} + +const model = 'deepseek-r1:1.5b'; + +const [,, prompt] = process.argv; + +main({ model, prompt }).catch(console.error); diff --git a/packages/nodejs/src/kernel/make-kernel.ts b/packages/nodejs/src/kernel/make-kernel.ts index aff23f67a..532519b7b 100644 --- a/packages/nodejs/src/kernel/make-kernel.ts +++ b/packages/nodejs/src/kernel/make-kernel.ts @@ -1,5 +1,5 @@ import type { KernelCommand, KernelCommandReply } from '@ocap/kernel'; -import { Kernel } from '@ocap/kernel'; +import { isKernelCommand, Kernel } from '@ocap/kernel'; import { NodeWorkerDuplexStream } from '@ocap/streams'; import { MessagePort as NodeMessagePort } from 'node:worker_threads'; @@ -20,7 +20,7 @@ export async function makeKernel( const nodeStream = new NodeWorkerDuplexStream< KernelCommand, KernelCommandReply - >(port); + >(port, isKernelCommand); const vatWorkerClient = new NodejsVatWorkerService({ workerFilePath }); // Initialize kernel store. diff --git a/packages/nodejs/src/kernel/sqlite-kv-store.ts b/packages/nodejs/src/kernel/sqlite-kv-store.ts index 0cf698bb0..40f054727 100644 --- a/packages/nodejs/src/kernel/sqlite-kv-store.ts +++ b/packages/nodejs/src/kernel/sqlite-kv-store.ts @@ -21,11 +21,10 @@ async function initDB( logger?: ReturnType, ): Promise { const dbPath = join(dbRoot, 'store.db'); - console.log('dbPath:', dbPath); await mkdir(dbRoot, { recursive: true }); - return new Sqlite(dbPath, { - verbose: (logger ?? console).info, - }); + return new Sqlite( + dbPath + ); } /** @@ -36,9 +35,9 @@ async function initDB( */ export async function makeSQLKVStore( label: string = '[sqlite]', + verbose: boolean = false, ): Promise { - const logger = makeLogger(label); - const db = await initDB(logger); + const db = await initDB(verbose ? makeLogger(label) : undefined); const sqlKVInit = db.prepare(` CREATE TABLE IF NOT EXISTS kv ( diff --git a/packages/nodejs/src/vats/ollama.bundle b/packages/nodejs/src/vats/ollama.bundle index d54af7e03..2b669cd3a 100644 --- a/packages/nodejs/src/vats/ollama.bundle +++ b/packages/nodejs/src/vats/ollama.bundle @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"88cd3fa179b5cbc4b734185d8b61aa20b1e02a17a1567b555e28af8ba37b81239a6e5500e78d6eb1823439eb9542c3b497f3dac773602d1eb2e363f6d4936fbe"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAAA9nQqL9joAAPY6AAAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgInRhZ3MiOiBbXSwKICAiZW50cnkiOiB7CiAgICAiY29tcGFydG1lbnQiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAibW9kdWxlIjogIi4vc3JjL3ZhdHMvb2xsYW1hLmpzIgogIH0sCiAgImNvbXBhcnRtZW50cyI6IHsKICAgICJAZW5kby9jb21tb24tdjEuMi44IjogewogICAgICAibmFtZSI6ICJAZW5kby9jb21tb24iLAogICAgICAibGFiZWwiOiAiQGVuZG8vY29tbW9uLXYxLjIuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9jb21tb24tdjEuMi44IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIi4vb2JqZWN0LW1hcC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJvYmplY3QtbWFwLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMTBlMDhjMTg3NmI4NDNjMWYwMDI3N2Y2ZDM0ZGRhM2JkOTMyOWRlNmE5ZjA5MzEzNTgyMDFmMTAwNGMyZjNhNjQxODlmNmZmMGVhYmZmOGJjNTYyNGQ0MDJjMWU3YzU3MmU2YWEzYmViYjkzMzhmMjM3NWYzZjgzMWFiYTM4ZjIiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZW52LW9wdGlvbnMiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNDE3NzZlZWIyMWIxYzU1MWRhM2Y5YjhkY2RmNWFiZDg4YmNiZjVmOGUzOGNiMDRlZGFiYzhjYjk2NGJiOTc1MThmZjRjYWNiNzQzZThhYmJhYWMyMjg2MTY4MTVmYmU0MGU4NmJlMmQ3ZDQyODE1Nzg5NTJmOGFhODY2YTFiOTciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW52LW9wdGlvbnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2Vudi1vcHRpb25zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOWNlYjEyZGU2ZDYxYTYzNDA3ODU1Mjg2ZTVlMTA3ODNiNTJkNTM0YjE1ZWViNjQ5YjllNTYxZDEwNjcwNzQ4NTE5MmU5NzkxNDFiNDIyNTllNjQ2OTliNjYxYjg5M2Y0NDI0NWQxMWM0YWFhMDcwZTE5Mzg0MGYzYjdlZDFhZTQiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL2Vycm9ycy12MS4yLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2Vycm9ycyIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Vycm9ycy12MS4yLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFmZDQxN2JjZGJkYWVjNjlkYTFhZGRlYmI1MWY2NTliYjhiMzE1ZGMxYzk2YjdmNzExNTZjNTU2MmYxN2NkOTE4Y2NhMDlkYmYwMjEyY2NiZTExZGQ5MGFiMzNhNTFiOWQxOWVhMzNjYTE5M2QxNjY1MjRlNzNiMzJiYTM1NWMyIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9lbnYtb3B0aW9ucyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL0UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL0UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmYzlkOTdkMDc5NGVhZTg2OGYzZDZjZGFiMWQ1Y2JiOTVmZTU2NmVjMGFhOGYzMWZjN2Q3OGUxMGQ5NTM1OWViMTYyZDY2MTg4MjJlYTIwNWRiNTJjMjVkZmI5NjgwZjFkMDkwZmZiMWY0YTRlYzhjZjFiZmE4MzVmNjVkNmJiNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9leHBvcnRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9leHBvcnRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTQ2NTVlODU5MzE5ODg0NzBiZGRhYjFmZWY1NTZlZjhiZmI3ZTI2MjUwYjZlZWU0NTU2MGQ4MGVkMWUzZWY4ZDViYjhlNWQwNThiNjA4NWVjZTJlMTdhZjIxNmQ4M2FhOTM5MDcwZTRlMmMxOTUyNTg5ODZiNzM2MDk5ZmFkOWMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbG9jYWwuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xvY2FsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOTZhNDgxYjYzY2MzNDEwNTQ1MGFhYjQzYTZmYmI0MDBhNjI1N2EwODM3ZWMzMzNkMzU4MmQwMjI0MmRjODUwODNlZTJiMWQ5ZmMzZGQxMGM5YTI0ODYyZTU2ZTI0OTE4MTJjZTE3ZmQwMzM0YzYxYWY0ZmIyMDlmM2Y3ZjZhNDMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImVjNzhiYmNiNzE1ZWY5MzlkZmY2N2E1MjZjOWEwYjIyYTBhMzIwMGQxMGM5NzNkOGRjMWVlYjk3Y2Y1Njg1NWU0OTZkM2I4ODQyNzY0YzIxNGVkZTUxZTFkYmUyNTM3NWRhMDEyMWE2ODhmM2I4YzFkMWY3YzlhNjNjMTRkMzYxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL25vLXNoaW0uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL25vLXNoaW0uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0YWM1Y2JiNDQ3Y2M1OTlkNTFhOTY0ZTI4NWUyOWMwOWJiYjkwN2Q3MmFiNjUzM2EyZDkzMmY1MWNjNzg1YzBjZmY5MzAwM2M1YmY1ZGIxMTYxZDM1YzNjZmEzYmY1MmE0Yjg4Yzg2NWNlNWZiODRmNTgzMjM2NzM1YmY1YWIyOCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90cmFjay10dXJucy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHJhY2stdHVybnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjYjAyMTc3ZjU0NWY1YTZjYTE0NGI4ZWEzYzgzMmM4OTg3MTFlOGVhMmNmNTQzOTU5ZjVhNWJiNzEyNGU1ZjA0N2U0OWMwMWQ4ZjUxOGQ1OGQwMDNjZmFkNDI4Njc0ZGM0NWQ1ZjUxMGU0YTRmNGI1MTRkY2Q1YTc1MWMzZTU2ZiIKICAgICAgICB9LAogICAgICAgICIuL3V0aWxzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInV0aWxzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmVhMDQxMWIyMTZjNzE0MTUxNDM5NjY2NGY4ZjgyMTNhY2QxMTJlOTMwYzBmNGZhYzAzNDI3ZjU3MzdkNzM3ZDBlOTQ2YjZjYzRjNjA4ODRkMDQwNTdiNzdmODgwOGEzOTY3MzY4NTk1NTg4NzI0MzVlYWVlZWQyZjEzMjY0N2QiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL21hcnNoYWwtdjEuNi4yIjogewogICAgICAibmFtZSI6ICJAZW5kby9tYXJzaGFsIiwKICAgICAgImxhYmVsIjogIkBlbmRvL21hcnNoYWwtdjEuNi4yIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL21hcnNoYWwtdjEuNi4yIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2NvbW1vbi9vYmplY3QtbWFwLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NvbW1vbi12MS4yLjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL29iamVjdC1tYXAuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXJyb3JzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Vycm9ycy12MS4yLjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmOTk3MWE0YmFmOTJiNTQ4ZTI0NzQ4ODBjMDdkYWJmMzYxZjJmZDAzOGM0MDBkYTUxZDBhNDQ2ODA5MmUzNjU1NTc2OTdjOGViMWNhZTMyNWNmZDlmYWY3MmFiODZjMTNmMDQyNDBhNmUxNDczYTdlMzkzODYyZGQwNDExYjU0ZSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlUGFzc2FibGUuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmMGRhY2ZhMTdhMDVmZTQzYjBjYWRjZDE4NjMwZGJmNTg2YmQyNGRhNDRhNzg4NTkwMDI1NTExZWQ4ZGVmYTBmMTI5ZDdiMjQzYjViOWNmMDYzMDNlNDE0Y2U3Yjc3NmY5MDg3ODBkMTU0YmQ5Mjg1NTcwMWE5ODIwZDExZDkxYiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb0NhcERhdGEuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVRvQ2FwRGF0YS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImUyMTM3NWVjNTE0YTJiMDEwNWNjMmZiZGVjYjM1YmI1MTk5YjIyZmZmNjkyOTA5YjM0Yzg0YmZjMTZkNzk5MGVmNWQzNDJjYjVmMDJjNmEzMjU3YjA3YThjYTM2MmM2YTIzMTUyMmI4ODlmODFkNDY4NWE0NjA3ZmJkODQ5NzBhIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2VuY29kZVRvU21hbGxjYXBzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImE1NThjYTBlM2E5NzBmNDNlZGVjN2E5Njk1MDZiZDgxZTRkOWVmY2Q5ZWVkYWNkODc0NzJlMWZjNDVkMDIyYWVkMDNmNzEyYmNhNTFhMmQ3ZWMxNDkyOWU1ZmUwODgyMzY0Mzc5MjA0MTNiMzVjYTBmOTg1N2VmMTE4MTZmY2Y0IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21hcnNoYWwtanVzdGluLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLWp1c3Rpbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZlNDE5NjY5ZjI3ZGYyMjUxZTAxY2UxNTg2ZWRjNWY3MjRiM2M2ODE5MzkzMTY2MDZkNTQ5ZGZjZmM5OWUwOTYyNmMxOWU0NjcwZjRkNzUyYzc5NGIwZjE5NzM5MWNjMGJkMzc1N2NjM2RhZWRkYTk3MmQ3ZjQ1NjgyZDNlZjE1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQ0Y2Y2ZGJlZjUzOWJiNDlhN2FlMWU4OTNkZmY0ZWViZDg1YmY3MTgxN2FkNzM4ODVjNTEyZjg2MGFlYWY5MmU3NDdlZmUzODY3YTFmODhjNjhhMWIyZjAyNzliNGI2YTQyNDMxZjA1YzM1YTM1N2EzZmUzN2E2NGMxNjViZDM5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21hcnNoYWwuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21hcnNoYWwuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhN2UzODFiNzE0MGQ1MzljZTZiODQ1OGVhZTdlNzJmMzhlNTI0ODEyOGFiZjIxZTlmNTY4YjU0NjQ4OWEyNjNjYmRhY2EyYjM0YTQ1NzE0ODI3MDg5Yjc0OTczODBkM2FhMDY2NjliNWRkYTc2OGQzOWM4MTliOGQ4N2UzY2VjOCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yYW5rT3JkZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JhbmtPcmRlci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjA5NjYzM2U4NmMwOTZmZjMyOGUyMzQ0MmZhZTRlZWFlYmQ2OWY0OGU4NDMzZGQ5OWQ4NTRiYmQ4YjcwMzdjODM2MzQyZGI2Mjg5NjNhYWNhMTljMjE3MjAxNWI2OGNmOTkxYmYxNGIxNWEzYjA5ZjMzZjAwYTNkMjRlYmVlMTI1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9uYXQtdjUuMC4xMyI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbmF0IiwKICAgICAgImxhYmVsIjogIkBlbmRvL25hdC12NS4wLjEzIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL25hdC12NS4wLjEzIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImVjNDJlMjY2MzJiYmFiNGJjOGY1OTE3ZDcyZjA3NDIzYzE2MjY0ZjJkNmEyMGY2ZGU4ZDE4OTY2NmEzZWYxOTY2OGI2YmQ1N2VlNjM4MzUyZjg4ZDljNjkyOTk4YWZlNjhiNTEzYThjMzNiZjY4MmQ4NmFmZTAzYTFlMTNhN2ViIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wYXNzLXN0eWxlLXYxLjQuNyI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vcGFzcy1zdHlsZSIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9wYXNzLXN0eWxlLXYxLjQuNyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wYXNzLXN0eWxlLXYxLjQuNyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9lbnYtb3B0aW9ucyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Vycm9ycyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kL3V0aWxzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi91dGlscy5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmOTkzMmQ1NGY1YjQxYWM3YjI0MWIwNDQ3ZGViYjVmNzkzNTlhNGNhYzUyZDdjYjY4NDU1NGQyNTE1MTk5Yjk5YTQ1ZjAxZmVjOTJhY2E0N2FhNWI3MTU5ZTRlZGI5NGFjN2NjNGIxYmE4NjE1YjIzOTQ0Mjg4MWVkODkwZmUxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb3B5QXJyYXkuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvcHlBcnJheS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjAxOThhMjg4NTJiNGNhMzY4YmY4N2ZhODRkNzBiYzdiY2Y5NTBkYzVjZjYzNTJhZjZjMWE5ODdjMTZlNzc0OTEwNDg1MWE0NTIwYzFmMzI3NmJkOTVkMjBkYTI3NThlNGE0MzQxZTA5Mjg2NDhjOWZjZDM5MGM0NGFkYzIyNDQzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvcHlSZWNvcmQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvcHlSZWNvcmQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmYTExODNjMjhmZTU3YzI2MzcyZmE1Yjk0NGEzODU3NmQ1ZGE2ZDkzMjBhZmY3NjRhYWU4OTE2NGE1YTA0YTU3M2ZhYjlkZGI5ZjZjMmNlOTY1ZTEyMWRiZGZhY2RhYzQzMTQ0MzM5ZTM4MzgzNjhjOTIxYjRiNjdhM2VmODM5OCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjkwNjdiNzU5ZjI0ZDQ5YTM5NzhjYzk0ZDMwNmI2MmVkMWVmZDIzYzc2ZTRjMWEyMjY0OGMzNWE3Y2QyNzFlODVlNjNkY2Y1M2FmN2Y1ZmEyMDdiM2UzNDliODA1N2RjMGMyMzk5NzA2ODA1M2VmYTljNmZjNjk3ZDRjMGU1ZDNhIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vycm9yLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lcnJvci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjI0ZWI0MWFmYjc5NzZiYjdhM2Y0NWQyOTU0ZWVjYWE1YTMzMjA3ZmYzMGI2OGYwYTNkNzFkYmQ1ZjRlZTUwNDVlODg3MDgyZjU4ZjA0MzYxODE5NmQzMDliMWU1NTI1MzEyNWUyMGJiZGIyMmZhMDI3ODJhMTRlZGMzYmU0ZmYzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2l0ZXItaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaXRlci1oZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiN2U0Yzk2MDhkMTVkNjNhN2NjNzU4MjJhYTcwZGI0YTc3MzBmMzJlMGNjNmFhNGJkM2I5MDBiMDUyOThlNTdiMTU1OWM5NjViNTQ5MmU0YTg1ZjhhMjBhNzY3ZGZmMmUxNzA1OGQwODc1MTNjNjg1MjYwZjQ1Y2Y5MmJiMjBjZGMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZS1mYXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2UtZmFyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTI2ZTY5ODEzNzUyMThkMDdiZmU1YzNiOGMyODdkYzIwNWVhMGQ1NTk2NGNiYzIxYmNhZmI3MzE5YTZhODkwZGQ1NTUzZWJmZGM3YTMyMzYxNDFhMWQ3NWU3NWE5NzI4ZTAzNTJlNzY1NTQ3YTQ0Mjc5YTVkY2Y3YTNiNWVjNTciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZVRhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFrZVRhZ2dlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjhhNTdmNGYxODcxMTQ2OGQ4MWUzMGU4MmJjNjBlNDcwNDIwMjY4MWYyNjk0YWQzYjA3NTNjYjNiZDIxY2Y5ZDQ5ZDc4ZjI3OWJhZTRmOWQxMjk2ODczMmQ0NjE5NTU4NmQ5NzI3M2FkYWY0ZDc2ZjhlYmY0MDgyNDIzYjAxODE1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGUtaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImE0YmYyY2Q2NWVhMjU0ZWViMzJlZDgwMjllMTM1MGQ4YTgxMmIzYTMzZWQwYzJjOTFjNzFkOGM3NGE5OWZhZmEzZTAyMjAxMDNmNjk1YjA3ZGIxNjEyMjdhYmE2M2ExYTlhYjA3NTg3YzQ1M2E1OGEwMDliOTQ1ZDQyMWZlMmIxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZU9mLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGVPZi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNhMjc1MDdjNTgyOGYzNDdlYWYyZjI3NWQ2Njk3MTI0NWViZTJkZGU2OTQ2MzA4MmMyMTVlNzdkMDI2NmZlOGZmMGNhMDgxNDBmOThlOWM0MjJhMDE2MmU2NzcxMTdjOTA0YzkzNzM3NGI2ZTM1M2JiNWE4MDc3NTUwYTNlNDAxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JlbW90YWJsZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmVtb3RhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzQxZTU4N2RiYmY1Njg5NGEwMWY3N2EyY2UzZGY5MGZkZDkyY2M3ZGIwMTEwNjQyZjk0NjQ0ZDY1NGFlMjcyYjNlNGZmMWQ4MTA0YzNlYjk2YjEzMjQ4ODdjN2Q2OGIzNDE2MTI4MjdkMDMxNDE4ZTk4Yjc2MzRjYzkwMTQzZWQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc2FmZS1wcm9taXNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zYWZlLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2MThiNmZhYmU4NjczNGYxZTllMTBlOTIyMDUxZjcwZjIzNjg4MWIxZmU4ODliMjYxNDU5NjhmMGJhOGI2ZDhkYTBlMDIyOTgwOTlkZjY4YzVjMDUyNWJkZjk0NTBhOTI5N2QzZDkyNjdmNzM2OTY0MjA4YmRjMzlhMDA2M2UyNyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdHJpbmcuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0cmluZy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImE1ZjhmNjBkYTM3NWM0ZGQ1NDVhZjYxMTBjNjY5YzQwMjQ4MjZjMjBlYjFhZThkOTJhM2IwMTI3NWM3ZDZjZWEzZGFkNmI5MjQyNWU2MDNlNDY3NzNlYzczMDY1MzU5YTYxOGM1N2VhYmIxNWU1ZmE5MDkxY2ZiMmQwMzE2MTBkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N5bWJvbC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3ltYm9sLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYzUzNzQwODE0N2E3MjM4ZGVkMWMzNzNlNmVlNmJhZjM0M2RhN2QyYzRjNTk1MmYyMzAyNTYwMWU1OGU1N2YyMmIzMjU5ZmEwMjJhY2U2OTRiNWMyODkwNjdkYjFmZmRmZDIyOTY0MmZjMGIzOWQ5NzE2YmZmYTkwZWYyMmRmMGQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdGFnZ2VkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90YWdnZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJiNTc1ZDE0NTFmNDdlYjNkODhjNTQzNWRlMTk0ZTBmNzYzZDc0NzYzYTMzMTdjM2FhMTVmNzZmNDUyNDNjYTkxMDY2ZWJjOTZhZjFlOTcyMDQwM2RhZWVmZGIyNTg2ZjczMWJlZWEyMzQzMGYwODc2NzdkNDNmMWUzZGM1YzJmMCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlR3VhcmRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlR3VhcmRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjljN2E5YzQ0ZTFjYzE2YzU3ODU3Y2M3MmRmODExZjliNmMyNmVjOWU2MzBkOGJiMTMxYWJiZTg1ZTJmNDc5ZDExMmE0NTQ3ZjI0MDE3OTQ3ODYxM2NmOTdlNDU0MTgzMDA3YWM1NDgwMGIxYThkNTYxNzhmMTg4MGVhYzA1YTYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTQ2NTVlODU5MzE5ODg0NzBiZGRhYjFmZWY1NTZlZjhiZmI3ZTI2MjUwYjZlZWU0NTU2MGQ4MGVkMWUzZWY4ZDViYjhlNWQwNThiNjA4NWVjZTJlMTdhZjIxNmQ4M2FhOTM5MDcwZTRlMmMxOTUyNTg5ODZiNzM2MDk5ZmFkOWMiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vcHJvbWlzZS1raXQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYWY0OTYyZTQ4M2Q4NGM4N2ZkOWI3OTVkN2QzZWJjNGRlMjAzZjk0ZDUwNDE4OGNjZWY0MWZmMDlkZTBiZWY1MjU0M2Y0ZjMxM2NhMTllYzE3ZmNjNGI4Y2Q4ODc3OGFhZDZmNjRjODEwMWQ4Mzc0NzhkOGI1OTRhMTA2NmM5N2MiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaXMtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaXMtcHJvbWlzZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc3NzMxNWE1MTYyMzVhMDIwNDhiM2M0ZGYxMDcxYzhiZjFmMWRlOTAzZDRjZThhOTJjOTU4ZTFlMGM3MjY0ZWRkMjJmNTc2MTk5ZjJmMTM5ZWIxZmQ2MjcwNWE4NTM2ZTc1MDJlMzg4NmNhM2Y1ZjI4OTMxMjRiZTgzYTRjOWE1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21lbW8tcmFjZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWVtby1yYWNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjRlZmM4ZjRkYTYwMGEzMTI2ZDI3Y2Q1MGFiMDE3MDI1MDMwYzJmMjRjOTlhYTE4MWI1MmE4NGRkMTM0YjE4NzE2OTEzNWU2NmVmMmViNjM2MzBiZWY3NjA3NDgzMzc3N2M0NTMwZjIzYTk0N2EzM2RjODUwMzI3ZjE1NDM4Y2UiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGUyYzRiNWNkZTM4ZTFmNDZmY2IwMDFhNDI3NDVhODIzMjE0OGU1MzFkNzZlYzk2YTZhYzk2Y2E4NWU2MTgwMzUyODI3MTkzMDE1NTMwZTZmNTJjNDk1MWM3ZjU2YTNhZGI2MWY2OWYyYzU5ZTU3MTJkYTk2NjUxOGIzOTc5NzUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTQ2NTVlODU5MzE5ODg0NzBiZGRhYjFmZWY1NTZlZjhiZmI3ZTI2MjUwYjZlZWU0NTU2MGQ4MGVkMWUzZWY4ZDViYjhlNWQwNThiNjA4NWVjZTJlMTdhZjIxNmQ4M2FhOTM5MDcwZTRlMmMxOTUyNTg5ODZiNzM2MDk5ZmFkOWMiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBvY2FwL25vZGVqcy12MC4wLjAiOiB7CiAgICAgICJuYW1lIjogIkBvY2FwL25vZGVqcyIsCiAgICAgICJsYWJlbCI6ICJAb2NhcC9ub2RlanMtdjAuMC4wIiwKICAgICAgImxvY2F0aW9uIjogIkBvY2FwL25vZGVqcy12MC4wLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdmF0cy9vbGxhbWEuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3ZhdHMvb2xsYW1hLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjczZjU1YzZjYTAyNDE3ZTI2YTQyOTM0ZWIwMjBkYzI2YmFkMzY3NjllZmEwMzIwZGY4MmI3NGMzMDE4YTliMzhiYmVjNTE3NGJkN2ZjMGQ1NzUyODEzYmU5YjM0NGM0OThiZjJjMzBiODllMzkwMjAxZGY2M2IyYjMyMTU5ZTAiCiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9UEsDBAoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAQGVuZG8vY29tbW9uLXYxLjIuOC9vYmplY3QtbWFwLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJvYmplY3RNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIGNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBCeSBhbmFsb2d5IHdpdGggaG93IGBBcnJheS5wcm90b3R5cGUubWFwYCB3aWxsIG1hcCB0aGUgZWxlbWVudHMgb2ZcbiAqIGFuIGFycmF5IHRvIHRyYW5zZm9ybWVkIGVsZW1lbnRzIG9mIGFuIGFycmF5IG9mIHRoZSBzYW1lIHNoYXBlLFxuICogYG9iamVjdE1hcGAgd2lsbCBkbyBsaWtld2lzZSBmb3IgdGhlIHN0cmluZy1uYW1lZCBvd24gZW51bWVyYWJsZVxuICogcHJvcGVydGllcyBvZiBhbiBvYmplY3QuXG4gKlxuICogVHlwaWNhbCB1c2FnZSBhcHBsaWVzIGBvYmplY3RNYXBgIHRvIGEgQ29weVJlY29yZCwgaS5lLixcbiAqIGFuIG9iamVjdCBmb3Igd2hpY2ggYHBhc3NTdHlsZU9mKG9yaWdpbmFsKSA9PT0gJ2NvcHlSZWNvcmQnYC4gRm9yIHRoZXNlLFxuICogbm9uZSBvZiB0aGUgZm9sbG93aW5nIGVkZ2UgY2FzZXMgYXJpc2UuIFRoZSByZXN1bHQgd2lsbCBiZSBhIENvcHlSZWNvcmRcbiAqIHdpdGggZXhhY3RseSB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lcywgd2hvc2UgdmFsdWVzIGFyZSB0aGUgbWFwcGVkIGZvcm0gb2ZcbiAqIHRoZSBvcmlnaW5hbCdzIHZhbHVlcy5cbiAqXG4gKiBXaGVuIHRoZSBvcmlnaW5hbCBpcyBub3QgYSBDb3B5UmVjb3JkLCBzb21lIGVkZ2UgY2FzZXMgdG8gYmUgYXdhcmUgb2ZcbiAqICAgICogTm8gbWF0dGVyIGhvdyBtdXRhYmxlIHRoZSBvcmlnaW5hbCBvYmplY3QsIHRoZSByZXR1cm5lZCBvYmplY3QgaXNcbiAqICAgICAgaGFyZGVuZWQuXG4gKiAgICAqIE9ubHkgdGhlIHN0cmluZy1uYW1lZCBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIG9mIHRoZSBvcmlnaW5hbFxuICogICAgICBhcmUgbWFwcGVkLiBBbGwgb3RoZXIgcHJvcGVydGllcyBhcmUgaWdub3JlZC5cbiAqICAgICogSWYgYW55IG9mIHRoZSBvcmlnaW5hbCBwcm9wZXJ0aWVzIHdlcmUgYWNjZXNzb3JzLCBgT2JqZWN0LmVudHJpZXNgXG4gKiAgICAgIHdpbGwgY2F1c2UgaXRzIGBnZXR0ZXJgIHRvIGJlIGNhbGxlZCBhbmQgd2lsbCB1c2UgdGhlIHJlc3VsdGluZ1xuICogICAgICB2YWx1ZS5cbiAqICAgICogTm8gbWF0dGVyIHdoZXRoZXIgdGhlIG9yaWdpbmFsIHByb3BlcnR5IHdhcyBhbiBhY2Nlc3Nvciwgd3JpdGFibGUsXG4gKiAgICAgIG9yIGNvbmZpZ3VyYWJsZSwgYWxsIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogICAgICBub24td3JpdGFibGUsIG5vbi1jb25maWd1cmFibGUsIGRhdGEgcHJvcGVydGllcy5cbiAqICAgICogTm8gbWF0dGVyIHdoYXQgdGhlIG9yaWdpbmFsIG9iamVjdCBtYXkgaGF2ZSBpbmhlcml0ZWQgZnJvbSwgYW5kXG4gKiAgICAgIG5vIG1hdHRlciB3aGV0aGVyIGl0IHdhcyBhIHNwZWNpYWwga2luZCBvZiBvYmplY3Qgc3VjaCBhcyBhbiBhcnJheSxcbiAqICAgICAgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGFsd2F5cyBiZSBhIHBsYWluIG9iamVjdCBpbmhlcml0aW5nIGRpcmVjdGx5XG4gKiAgICAgIGZyb20gYE9iamVjdC5wcm90b3R5cGVgIGFuZCB3aG9zZSBzdGF0ZSBpcyBvbmx5IHRoZXNlIG5ldyBtYXBwZWRcbiAqICAgICAgb3duIHByb3BlcnRpZXMuXG4gKlxuICogV2l0aCB0aGVzZSBkaWZmZXJlbmNlcywgZXZlbiBpZiB0aGUgb3JpZ2luYWwgb2JqZWN0IHdhcyBub3QgYSBDb3B5UmVjb3JkLFxuICogaWYgYWxsIHRoZSBtYXBwZWQgdmFsdWVzIGFyZSBQYXNzYWJsZSwgdGhlbiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqIGEgQ29weVJlY29yZC5cbiAqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIGFueT59IE9cbiAqIEB0ZW1wbGF0ZSBSIG1hcCByZXN1bHRcbiAqIEBwYXJhbSB7T30gb3JpZ2luYWxcbiAqIEBwYXJhbSB7KHZhbHVlOiBPW2tleW9mIE9dLCBrZXk6IGtleW9mIE8pID0+IFJ9IG1hcEZuXG4gKiBAcmV0dXJucyB7UmVjb3JkPGtleW9mIE8sIFI+fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKFxuKFtrLHZdKT0+LyoqIEB0eXBlIHtba2V5b2YgTywgUl19ICovW2ssbWFwRm4odixrKV0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7UmVjb3JkPGtleW9mIE8sIFI+fSAqL2hhcmRlbihmcm9tRW50cmllcyhtYXBFbnRzKSkpO1xuIH07JGjNj19vbmNlLm9iamVjdE1hcChvYmplY3RNYXApO1xuaGFyZGVuKG9iamVjdE1hcCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJvYmplY3RNYXAiOlsib2JqZWN0TWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUY5zqUAQAAlAEAACEAAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW52LW9wdGlvbnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy9lbnYtb3B0aW9ucy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvZW52LW9wdGlvbnMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAXZuU6h4TAAAeEwAAKwAAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiLCJnZXRFbnZpcm9ubWVudE9wdGlvbiIsImdldEVudmlyb25tZW50T3B0aW9uc0xpc3QiLCJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtY2hlY2sqL1xuXG4vKiBgQGVuZG8vZW52LW9wdGlvbnNgIG5lZWRzIHRvIGJlIGltcG9ydGVkIHF1aXRlIGVhcmx5LCBhbmQgc28gc2hvdWxkKi9cbi8qIGF2b2lkIGltcG9ydGluZyBmcm9tIHNlcyBvciBhbnl0aGluZyB0aGF0IGRlcGVuZHMgb24gc2VzLiovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cbi8qIFByZWx1ZGUgb2YgY2hlYXAgZ29vZCAtIGVub3VnaCBpbWl0YXRpb25zIG9mIHRoaW5ncyB3ZSdkIHVzZSBvciovXG4vKiBkbyBkaWZmZXJlbnRseSBpZiB3ZSBjb3VsZCBkZXBlbmQgb24gc2VzKi9cblxuY29uc3R7ZnJlZXplfT1PYmplY3Q7XG5jb25zdHthcHBseX09UmVmbGVjdDtcblxuLyogU2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gdGhlIG9uZSBpbiBzZXMnIGNvbW1vbnMuanMgZXZlbiB0aG91Z2ggaXQqL1xuLyogdXNlcyB0aGUgb3RoZXIgdGVjaG5pcXVlLiovXG5jb25zdCB1bmN1cnJ5VGhpcz1cbihmbik9PlxuKHJlY2VpdmVyLC4uLmFyZ3MpPT5cbmFwcGx5KGZuLHJlY2VpdmVyLGFyZ3MpO1xuY29uc3QgYXJyYXlQdXNoPXVuY3VycnlUaGlzKEFycmF5LnByb3RvdHlwZS5wdXNoKTtcbmNvbnN0IGFycmF5SW5jbHVkZXM9dW5jdXJyeVRoaXMoQXJyYXkucHJvdG90eXBlLmluY2x1ZGVzKTtcbmNvbnN0IHN0cmluZ1NwbGl0PXVuY3VycnlUaGlzKFN0cmluZy5wcm90b3R5cGUuc3BsaXQpO1xuXG5jb25zdCBxPUpTT04uc3RyaW5naWZ5O1xuXG5jb25zdCBGYWlsPShsaXRlcmFscywuLi5hcmdzKT0+e1xubGV0IG1zZz1saXRlcmFsc1swXTtcbmZvcihsZXQgaT0wO2k8YXJncy5sZW5ndGg7aSs9MSl7XG5tc2c9IGAke21zZ30ke2FyZ3NbaV19JHtsaXRlcmFsc1tpKzFdfWA7XG4gfVxudGhyb3cgRXJyb3IobXNnKTtcbiB9O1xuXG4vKiBlbmQgcHJlbHVkZSovXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogYG1ha2VFbnZpcm9ubWVudENhcHRvcmAgcHJvdmlkZXMgYSBtZWNoYW5pc20gZm9yIGdldHRpbmcgZW52aXJvbm1lbnRcbiAqIHZhcmlhYmxlcywgaWYgdGhleSBhcmUgbmVlZGVkLCBhbmQgYSB3YXkgdG8gY2F0YWxvZyB0aGUgbmFtZXMgb2YgYWxsXG4gKiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQgd2VyZSBjYXB0dXJlZC5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gYUdsb2JhbFxuICogQHBhcmFtIHtib29sZWFufSBbZHJvcE5hbWVzXSBEZWZhdWx0cyB0byBmYWxzZS4gSWYgdHJ1ZSwgZG9uJ3QgdHJhY2tcbiAqIG5hbWVzIHVzZWQuXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW52aXJvbm1lbnRDYXB0b3I9KGFHbG9iYWwsZHJvcE5hbWVzPWZhbHNlKT0+e1xuY29uc3QgY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzPVtdO1xuXG4vKipcbiAqIEdldHMgYW4gZW52aXJvbm1lbnQgb3B0aW9uIGJ5IG5hbWUgYW5kIHJldHVybnMgdGhlIG9wdGlvbiB2YWx1ZSBvciB0aGVcbiAqIGdpdmVuIGRlZmF1bHQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbk5hbWVcbiAqIEBwYXJhbSB7c3RyaW5nfSBkZWZhdWx0U2V0dGluZ1xuICogQHBhcmFtIHtzdHJpbmdbXX0gW29wdE90aGVyVmFsdWVzXVxuICogSWYgcHJvdmlkZWQsIHRoZSBvcHRpb24gdmFsdWUgbXVzdCBiZSBpbmNsdWRlZCBvciBtYXRjaCBgZGVmYXVsdFNldHRpbmdgLlxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZ2V0RW52aXJvbm1lbnRPcHRpb249KFxub3B0aW9uTmFtZSxcbmRlZmF1bHRTZXR0aW5nLFxub3B0T3RoZXJWYWx1ZXM9dW5kZWZpbmVkKT0+XG57XG50eXBlb2Ygb3B0aW9uTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYEVudmlyb25tZW50IG9wdGlvbiBuYW1lICR7cShvcHRpb25OYW1lKX0gbXVzdCBiZSBhIHN0cmluZy5gO1xudHlwZW9mIGRlZmF1bHRTZXR0aW5nPT09J3N0cmluZyd8fFxuRmFpbCBgRW52aXJvbm1lbnQgb3B0aW9uIGRlZmF1bHQgc2V0dGluZyAke3EoXG5kZWZhdWx0U2V0dGluZylcbiB9IG11c3QgYmUgYSBzdHJpbmcuYDtcblxuLyoqIEB0eXBlIHtzdHJpbmd9ICovXG5sZXQgc2V0dGluZz1kZWZhdWx0U2V0dGluZztcbmNvbnN0IGdsb2JhbFByb2Nlc3M9YUdsb2JhbC5wcm9jZXNzfHx1bmRlZmluZWQ7XG5jb25zdCBnbG9iYWxFbnY9XG50eXBlb2YgZ2xvYmFsUHJvY2Vzcz09PSdvYmplY3QnJiZnbG9iYWxQcm9jZXNzLmVudnx8dW5kZWZpbmVkO1xuaWYodHlwZW9mIGdsb2JhbEVudj09PSdvYmplY3QnKXtcbmlmKG9wdGlvbk5hbWUgaW4gZ2xvYmFsRW52KXtcbmlmKCFkcm9wTmFtZXMpe1xuYXJyYXlQdXNoKGNhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcyxvcHRpb25OYW1lKTtcbiB9XG5jb25zdCBvcHRpb25WYWx1ZT1nbG9iYWxFbnZbb3B0aW9uTmFtZV07XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2Ygb3B0aW9uVmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gbmFtZWQgJHtxKFxub3B0aW9uTmFtZSlcbiB9LCBpZiBwcmVzZW50LCBtdXN0IGhhdmUgYSBjb3JyZXNwb25kaW5nIHN0cmluZyB2YWx1ZSwgZ290ICR7cShcbm9wdGlvblZhbHVlKVxuIH1gO1xuc2V0dGluZz1vcHRpb25WYWx1ZTtcbiB9XG4gfVxub3B0T3RoZXJWYWx1ZXM9PT11bmRlZmluZWR8fFxuc2V0dGluZz09PWRlZmF1bHRTZXR0aW5nfHxcbmFycmF5SW5jbHVkZXMob3B0T3RoZXJWYWx1ZXMsc2V0dGluZyl8fFxuRmFpbCBgVW5yZWNvZ25pemVkICR7cShvcHRpb25OYW1lKX0gdmFsdWUgJHtxKFxuc2V0dGluZylcbiB9LiBFeHBlY3RlZCBvbmUgb2YgJHtxKFtkZWZhdWx0U2V0dGluZywuLi5vcHRPdGhlclZhbHVlc10pfWA7XG5yZXR1cm4gc2V0dGluZztcbiB9O1xuZnJlZXplKGdldEVudmlyb25tZW50T3B0aW9uKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5jb25zdCBnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0PShvcHRpb25OYW1lKT0+e1xuY29uc3Qgb3B0aW9uPWdldEVudmlyb25tZW50T3B0aW9uKG9wdGlvbk5hbWUsJycpO1xucmV0dXJuIGZyZWV6ZShvcHRpb249PT0nJz9bXTpzdHJpbmdTcGxpdChvcHRpb24sJywnKSk7XG4gfTtcbmZyZWV6ZShnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTtcblxuY29uc3QgZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcz0ob3B0aW9uTmFtZSxlbGVtZW50KT0+XG5hcnJheUluY2x1ZGVzKGdldEVudmlyb25tZW50T3B0aW9uc0xpc3Qob3B0aW9uTmFtZSksZWxlbWVudCk7XG5cbmNvbnN0IGdldENhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcz0oKT0+e1xucmV0dXJuIGZyZWV6ZShbLi4uY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzXSk7XG4gfTtcbmZyZWV6ZShnZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXMpO1xuXG5yZXR1cm4gZnJlZXplKHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMsXG5nZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXN9KTtcblxuIH07JGjNj19vbmNlLm1ha2VFbnZpcm9ubWVudENhcHRvcihtYWtlRW52aXJvbm1lbnRDYXB0b3IpO1xuZnJlZXplKG1ha2VFbnZpcm9ubWVudENhcHRvcik7XG5cbi8qKlxuICogRm9yIHRoZSBzaW1wbGUgY2FzZSwgd2hlcmUgdGhlIGdsb2JhbCBpbiBxdWVzdGlvbiBpcyBgZ2xvYmFsVGhpc2AgYW5kIG5vXG4gKiByZXBvcnRpbmcgb2Ygb3B0aW9uIG5hbWVzIGlzIGRlc2lyZWQuXG4gKi9cbmNvbnN0ICAgICAgIHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXN9PVxubWFrZUVudmlyb25tZW50Q2FwdG9yKGdsb2JhbFRoaXMsdHJ1ZSk7JGjNj19vbmNlLmdldEVudmlyb25tZW50T3B0aW9uKGdldEVudmlyb25tZW50T3B0aW9uKTskaM2PX29uY2UuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdChnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTskaM2PX29uY2UuZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyhlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbnZpcm9ubWVudENhcHRvciI6WyJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwiZ2V0RW52aXJvbm1lbnRPcHRpb24iOlsiZ2V0RW52aXJvbm1lbnRPcHRpb24iXSwiZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCI6WyJnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0Il0sImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiOlsiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADnjB5W6QwAAOkMAAAcAAAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiRmFpbCIsIlgiLCJhbm5vdGF0ZUVycm9yIiwiYXNzZXJ0IiwiYiIsImJhcmUiLCJtYWtlRXJyb3IiLCJub3RlIiwicSIsInF1b3RlIiwicmVkYWN0ZWQiLCJ0aHJvd1JlZGFjdGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogVGhpcyBtb2R1bGUgYXNzdW1lcyB0aGUgZXhpc3RlbmNlIG9mIGEgbm9uLXN0YW5kYXJkIGBhc3NlcnRgIGhvc3Qgb2JqZWN0LiovXG4vKiBTRVMgdmVyc2lvbiAwLjExLjAgaW50cm9kdWNlcyB0aGlzIGdsb2JhbCBvYmplY3QgYW5kIGVudGFuZ2xlcyBpdCovXG4vKiB3aXRoIHRoZSBgY29uc29sZWAgaG9zdCBvYmplY3QgaW4gc2NvcGUgd2hlbiBpdCBpbml0aWFsaXplcywqL1xuLyogYWxsb3dpbmcgZXJyb3JzLCBwYXJ0aWN1bGFybHkgYXNzZXJ0aW9uIGVycm9ycywgdG8gaGlkZSB0aGVpciBcImRldGFpbHNcIiovXG4vKiBmcm9tIGNhbGxlcnMgdGhhdCBtaWdodCBjYXRjaCB0aG9zZSBlcnJvcnMsIHRoZW4gcmV2ZWFsIHRoZW0gdG8gdGhlKi9cbi8qIHVuZGVybHlpbmcgY29uc29sZS4qL1xuLyogVG8gdGhlIGV4dGVudCB0aGF0IHRoaXMgYGNvbnNvbGVgIGlzIGNvbnNpZGVyZWQgYSByZXNvdXJjZSwqL1xuLyogdGhpcyBtb2R1bGUgbXVzdCBiZSBjb25zaWRlcmVkIGEgcmVzb3VyY2UgbW9kdWxlLiovXG5cbi8qIFRoZSBhc3NlcnRpb25zIHJlLWV4cG9ydGVkIGhlcmUgYXJlIGRlZmluZWQgaW4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL2Fzc2VydC5qcyovXG5cbmNvbnN0IGdsb2JhbEFzc2VydD1nbG9iYWxUaGlzLmFzc2VydDtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAZW5kby9lcnJvcnMsIG1pc3NpbmcgZ2xvYmFsVGhpcy5hc3NlcnQsIGltcG9ydCAnc2VzJyBiZWZvcmUgJ0BlbmRvL2Vycm9ycydgKTtcblxuIH1cblxuY29uc3QgbWlzc2luZz0vKiogQHR5cGUge2NvbnN0fSAqL1tcbid0eXBlb2YnLFxuJ2Vycm9yJyxcbidmYWlsJyxcbidlcXVhbCcsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyB0aGF0Ki9cbi8qIHByZWRhdGVzIGFkZGl0aW9uIG9mIHRoZSAnYmFyZScgbWV0aG9kLCBzbyB3ZSBtdXN0IHRvbGVyYXRlIGl0cyBhYnNlbmNlIGFuZCBmYWxsKi9cbi8qIGJhY2sgdG8gcXVvdGUgYmVoYXZpb3IgaW4gdGhhdCBlbnZpcm9ubWVudCAoc2VlIGJlbG93KS4qL1xuLyogJ2JhcmUnLCovXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBlbmRvL2Vycm9ycywgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCBtZXRob2RzICR7bWlzc2luZy5qb2luKFxuJywgJylcbiB9YCk7XG5cbiB9XG5cbi8qIFRoZSBnbG9iYWwgYXNzZXJ0IG1peGVkIGFzc2VydGlvbnMgYW5kIHV0aWxpdHkgZnVuY3Rpb25zLiovXG4vKiBUaGlzIG1vZHVsZSBzcGxpdHMgdGhlbSBhcGFydCovXG4vKiBhbmQgYWxzbyB1cGRhdGVzIHRoZSBuYW1lcyBvZiB0aGUgdXRpbGl0eSBmdW5jdGlvbnMuKi9cbmNvbnN0e1xuYmFyZSxcbmRldGFpbHM6cmVkYWN0ZWQsXG5lcnJvcjptYWtlRXJyb3IsXG5GYWlsOnRocm93UmVkYWN0ZWQsXG5tYWtlQXNzZXJ0Ol9vbWl0dGVkTWFrZUFzc2VydCxcbm5vdGUsXG5xdW90ZSxcbi4uLmFzc2VydGlvbnN9PVxuZ2xvYmFsQXNzZXJ0O1xuLyoqIEB0eXBlIHtJTVBPUlQoXCJzZXNcIikuQXNzZXJ0aW9uRnVuY3Rpb25zIH0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgbWlzc2luZyBwcm9wZXJ0aWVzIGFzc2lnbmVkIG5leHQqLyRozY9fb25jZS5yZWRhY3RlZChyZWRhY3RlZCk7JGjNj19vbmNlLm1ha2VFcnJvcihtYWtlRXJyb3IpOyRozY9fb25jZS50aHJvd1JlZGFjdGVkKHRocm93UmVkYWN0ZWQpOyRozY9fb25jZS5ub3RlKG5vdGUpOyRozY9fb25jZS5xdW90ZShxdW90ZSk7XG5jb25zdCBhc3NlcnQ9KHZhbHVlLG9wdERldGFpbHMsZXJyQ29udHJ1Y3RvcixvcHRpb25zKT0+XG5nbG9iYWxBc3NlcnQodmFsdWUsb3B0RGV0YWlscyxlcnJDb250cnVjdG9yLG9wdGlvbnMpOyRozY9fb25jZS5hc3NlcnQoYXNzZXJ0KTtcbk9iamVjdC5hc3NpZ24oYXNzZXJ0LGFzc2VydGlvbnMpO1xuXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyovXG4vKiB0aGF0IHByZWRhdGVzIHRoZSBhZGRpdGlvbiBvZiB0aGUgJ2JhcmUnIG1ldGhvZCwgc28gd2UgbXVzdCBmYWxsIGJhY2sgdG8qL1xuLyogcXVvdGUgYmVoYXZpb3IgZm9yIHRoYXQgZW52aXJvbm1lbnQuKi9cbmNvbnN0IGJhcmVPclF1b3RlPWJhcmV8fHF1b3RlO1xuXG4vKiBYWFggbW9kdWxlIGV4cG9ydHMgZmFpbCBpZiB0aGVzZSBhcmVuJ3QgaW4gc2NvcGUqL1xuLyoqIEBpbXBvcnQge0Fzc2VydE1ha2VFcnJvck9wdGlvbnMsIERldGFpbHMsIEdlbmVyaWNFcnJvckNvbnN0cnVjdG9yfSBmcm9tICdzZXMnICovJGjNj19vbmNlLmJhcmVPclF1b3RlKGJhcmVPclF1b3RlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlZGFjdGVkIjpbInJlZGFjdGVkIl0sIlgiOlsicmVkYWN0ZWQiXSwibWFrZUVycm9yIjpbIm1ha2VFcnJvciJdLCJ0aHJvd1JlZGFjdGVkIjpbInRocm93UmVkYWN0ZWQiXSwiRmFpbCI6WyJ0aHJvd1JlZGFjdGVkIl0sIm5vdGUiOlsibm90ZSJdLCJhbm5vdGF0ZUVycm9yIjpbIm5vdGUiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJhc3NlcnQiOlsiYXNzZXJ0Il0sImJhcmUiOlsiYmFyZU9yUXVvdGUiXSwiYiI6WyJiYXJlT3JRdW90ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL0UuanN7ImltcG9ydHMiOlsiLi90cmFjay10dXJucy5qcyIsIi4vbWVzc2FnZS1icmVha3BvaW50cy5qcyJdLCJleHBvcnRzIjpbImRlZmF1bHQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgdHJhY2tUdXJucyxtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXI7JGjNj19pbXBvcnRzKFtbXCIuL3RyYWNrLXR1cm5zLmpzXCIsIFtbXCJ0cmFja1R1cm5zXCIsIFskaM2PX2EgPT4gKHRyYWNrVHVybnMgPSAkaM2PX2EpXV1dXSxbXCIuL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW1tcIm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlclwiLCBbJGjNj19hID0+IChtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWwsZXJyb3I6bWFrZUVycm9yfT1hc3NlcnQ7XG5jb25zdHthc3NpZ24sZnJlZXplfT1PYmplY3Q7XG5cbi8qKlxuICogQGltcG9ydCB7IEhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3IgfSBmcm9tICcuL3R5cGVzLmpzJztcbiAqL1xuXG5jb25zdCBvblNlbmQ9bWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyKCdFTkRPX1NFTkRfQlJFQUtQT0lOVFMnKTtcblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qIEUgUHJveHkgaGFuZGxlcnMgcHJldGVuZCB0aGF0IGFueSBwcm9wZXJ0eSBleGlzdHMgb24gdGhlIHRhcmdldCBhbmQgcmV0dXJucyovXG4vKiBhIGZ1bmN0aW9uIGZvciB0aGVpciB2YWx1ZS4gV2hpbGUgdGhpcyBmdW5jdGlvbiBpcyBcImJvdW5kXCIgYnkgY29udGV4dCwgaXQgaXMqL1xuLyogbWVhbnQgdG8gYmUgY2FsbGVkIGFzIGEgbWV0aG9kLiBGb3IgdGhhdCByZWFzb24sIHRoZSByZXR1cm5lZCBmdW5jdGlvbiovXG4vKiBpbmNsdWRlcyBhIGNoZWNrIHRoYXQgdGhlIGB0aGlzYCBhcmd1bWVudCBjb3JyZXNwb25kcyB0byB0aGUgaW5pdGlhbCovXG4vKiByZWNlaXZlciB3aGVuIHRoZSBmdW5jdGlvbiB3YXMgcmV0cmlldmVkLiovXG4vKiBFIFByb3h5IGhhbmRsZXJzIGFsc28gZm9yd2FyZCBkaXJlY3QgY2FsbHMgdG8gdGhlIHRhcmdldCBpbiBjYXNlIHRoZSByZW1vdGUqL1xuLyogaXMgYSBmdW5jdGlvbiBpbnN0ZWFkIG9mIGFuIG9iamVjdC4gTm8gc3VjaCByZWNlaXZlciBjaGVja3MgYXJlIG5lY2Vzc2FyeSBpbiovXG4vKiB0aGF0IGNhc2UuKi9cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHthbnl9IHJlY2lwaWVudCBBbnkgdmFsdWUgcGFzc2VkIHRvIEUoeClcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXI8dW5rbm93bj59IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFUHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IFByb21pc2U8dW5rbm93bj59ICovXG5bcHJvcGVydHlLZXldKC4uLmFyZ3Mpe1xuaWYodGhpcyE9PXJlY2VpdmVyKXtcbi8qIFJlamVjdCB0aGUgYXN5bmMgZnVuY3Rpb24gY2FsbCovXG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVqZWN0KFxubWFrZUVycm9yKFxuWCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3EocHJvcGVydHlLZXkpfVwiIG1ldGhvZCBvZiBFKCR7cShcbnJlY2lwaWVudClcbiB9KWApKTtcblxuXG4gfVxuXG5pZihvblNlbmQmJm9uU2VuZC5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxwcm9wZXJ0eUtleSkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBtZXRob2QtY2FsbCovXG4vKiBtZXNzYWdlLCovXG4vKiBzbyB0aGF0IHlvdSBjYW4gd2FsayBiYWNrIG9uIHRoZSBzdGFjayB0byBzZWUgaG93IHdlIGNhbWUgdG8qL1xuLyogbWFrZSB0aGlzIGV2ZW50dWFsLXNlbmQqL1xuIH1cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZChyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucHJvcGVydHlLZXldKTtcblxuIH0sXG5hcHBseTooX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSk9PntcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBmdW5jdGlvbi1jYWxsIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ0FycmF5KTtcbiB9LFxuaGFzOihfdGFyZ2V0LF9wKT0+e1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUuc2VuZE9ubHkoeClcbiAqIEl0IGlzIGEgdmFyaWFudCBvbiB0aGUgRSh4KSBQcm94eSBoYW5kbGVyLlxuICpcbiAqIEBwYXJhbSB7YW55fSByZWNpcGllbnQgQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge0hhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7UHJveHlIYW5kbGVyPHVua25vd24+fSB0aGUgUHJveHkgaGFuZGxlclxuICovXG5jb25zdCBtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IHVuZGVmaW5lZH0gKi9cbltwcm9wZXJ0eUtleV0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShcbnByb3BlcnR5S2V5KVxuIH1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EocmVjaXBpZW50KX0pYDtcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHByb3BlcnR5S2V5KSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIG1ldGhvZC1jYWxsKi9cbi8qIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxuSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2RTZW5kT25seShyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDMxOSovfVtcbnByb3BlcnR5S2V5XSk7XG5cbiB9LFxuYXBwbHk6KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKT0+e1xuaWYob25TZW5kJiZvblNlbmQuc2hvdWxkQnJlYWtwb2ludChyZWNpcGllbnQsdW5kZWZpbmVkKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIGZ1bmN0aW9uLWNhbGwgbWVzc2FnZSwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHdhbGsgYmFjayBvbiB0aGUgc3RhY2sgdG8gc2VlIGhvdyB3ZSBjYW1lIHRvKi9cbi8qIG1ha2UgdGhpcyBldmVudHVhbC1zZW5kKi9cbiB9XG5IYW5kbGVkUHJvbWlzZS5hcHBseUZ1bmN0aW9uU2VuZE9ubHkocmVjaXBpZW50LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXM6KF90YXJnZXQsX3ApPT57XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLmdldCh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHthbnl9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLmdldCh4KVxuICogQHBhcmFtIHtIYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcjx1bmtub3duPn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuY29uc3QgbWFrZUVHZXRQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzOihfdGFyZ2V0LF9wcm9wKT0+dHJ1ZSxcbmdldDooX3RhcmdldCxwcm9wKT0+SGFuZGxlZFByb21pc2UuZ2V0KHgscHJvcCl9KTtcblxuXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBmdW5jVGFyZ2V0PWZyZWV6ZSgoKT0+eyB9KTtcblxuLyoqXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBvYmpUYXJnZXQ9ZnJlZXplKHtfX3Byb3RvX186bnVsbH0pO1xuXG4vKipcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqL1xuY29uc3QgbWFrZUU9KEhhbmRsZWRQcm9taXNlKT0+e1xucmV0dXJuIGhhcmRlbihcbmFzc2lnbihcbi8qKlxuICogRSh4KSByZXR1cm5zIGEgcHJveHkgb24gd2hpY2ggeW91IGNhbiBjYWxsIGFyYml0cmFyeSBtZXRob2RzLiBFYWNoIG9mIHRoZXNlXG4gKiBtZXRob2QgY2FsbHMgcmV0dXJucyBhIHByb21pc2UuIFRoZSBtZXRob2Qgd2lsbCBiZSBpbnZva2VkIG9uIHdoYXRldmVyXG4gKiAneCcgZGVzaWduYXRlcyAob3IgcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgbWV0aG9kL2Z1bmN0aW9uIGNhbGxcbiAqIEByZXR1cm5zIHtFQ2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqL1xuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG4oeCk9Pm5ldyBQcm94eShmdW5jVGFyZ2V0LG1ha2VFUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcbntcbi8qKlxuICogRS5nZXQoeCkgcmV0dXJucyBhIHByb3h5IG9uIHdoaWNoIHlvdSBjYW4gZ2V0IGFyYml0cmFyeSBwcm9wZXJ0aWVzLlxuICogRWFjaCBvZiB0aGVzZSBwcm9wZXJ0aWVzIHJldHVybnMgYSBwcm9taXNlIGZvciB0aGUgcHJvcGVydHkuICBUaGUgcHJvbWlzZVxuICogdmFsdWUgd2lsbCBiZSB0aGUgcHJvcGVydHkgZmV0Y2hlZCBmcm9tIHdoYXRldmVyICd4JyBkZXNpZ25hdGVzIChvclxuICogcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgcHJvcGVydHkgZ2V0XG4gKiBAcmV0dXJucyB7RUdldHRlcnM8TG9jYWxSZWNvcmQ8VD4+fSBwcm9wZXJ0eSBnZXQgcHJveHlcbiAqIEByZWFkb25seVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCB0eXBlZGVmKi9cbmdldDooeCk9Pm5ldyBQcm94eShvYmpUYXJnZXQsbWFrZUVHZXRQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSkpLFxuXG4vKipcbiAqIEUucmVzb2x2ZSh4KSBjb252ZXJ0cyB4IHRvIGEgaGFuZGxlZCBwcm9taXNlLiBJdCBpc1xuICogc2hvcnRoYW5kIGZvciBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gaGFuZGxlZCBwcm9taXNlIGZvciB4XG4gKiBAcmVhZG9ubHlcbiAqL1xucmVzb2x2ZTpIYW5kbGVkUHJvbWlzZS5yZXNvbHZlLFxuXG4vKipcbiAqIEUuc2VuZE9ubHkgcmV0dXJucyBhIHByb3h5IHNpbWlsYXIgdG8gRSwgYnV0IGZvciB3aGljaCB0aGUgcmVzdWx0c1xuICogYXJlIGlnbm9yZWQgKHVuZGVmaW5lZCBpcyByZXR1cm5lZCkuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB0YXJnZXQgZm9yIG1ldGhvZC9mdW5jdGlvbiBjYWxsXG4gKiBAcmV0dXJucyB7RVNlbmRPbmx5Q2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqIEByZWFkb25seVxuICovXG5zZW5kT25seTooeCk9PlxuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG5uZXcgUHJveHkoZnVuY1RhcmdldCxtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcblxuLyoqXG4gKiBFLndoZW4oeCwgcmVzLCByZWopIGlzIGVxdWl2YWxlbnQgdG9cbiAqIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihyZXMsIHJlailcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtVID0gVF1cbiAqIEBwYXJhbSB7VHxQcm9taXNlTGlrZTxUPn0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gRVJlZjxVPn0gW29uZnVsZmlsbGVkXVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IEVSZWY8VT59IFtvbnJlamVjdGVkXVxuICogQHJldHVybnMge1Byb21pc2U8VT59XG4gKiBAcmVhZG9ubHlcbiAqL1xud2hlbjooeCxvbmZ1bGZpbGxlZCxvbnJlamVjdGVkKT0+XG5IYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4oXG4uLi50cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSkpfSkpO1xuXG5cblxuXG4gfTtcblxuY29uc3R7ZGVmYXVsdDokY82PX2RlZmF1bHR9PXtkZWZhdWx0Om1ha2VFfTtcblxuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPG1ha2VFPn0gRVByb3h5ICovXG5cbi8qKlxuICogRGVjbGFyZSBhbiBvYmplY3QgdGhhdCBpcyBwb3RlbnRpYWxseSBhIGZhciByZWZlcmVuY2Ugb2YgdHlwZSBQcmltYXJ5IHdob3NlXG4gKiBhdXhpbGxpYXJ5IGRhdGEgaGFzIHR5cGUgTG9jYWwuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yIGNvbnN1bWVycyBvZlxuICogRmFyIG9iamVjdHMgaW4gYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHRoZSBvbmx5IGNyZWF0b3JzIG9mIEZhciBvYmplY3RzXG4gKiBhcmUgZGlzdHJpYnV0ZWQgb2JqZWN0IGNyZWF0b3IgY29tcG9uZW50cyBsaWtlIHRoZSBgRmFyYCBvciBgUmVtb3RhYmxlYFxuICogZnVuY3Rpb25zLlxuICpcbiAqIEB0ZW1wbGF0ZSBQcmltYXJ5IFRoZSB0eXBlIG9mIHRoZSBwcmltYXJ5IHJlZmVyZW5jZS5cbiAqIEB0ZW1wbGF0ZSBbTG9jYWw9RGF0YU9ubHk8UHJpbWFyeT5dIFRoZSBsb2NhbCBwcm9wZXJ0aWVzIG9mIHRoZSBvYmplY3QuXG4gKiBAdHlwZWRlZiB7RVJlZjxMb2NhbCAmIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPExvY2FsLCBQcmltYXJ5Pj59IEZhclJlZlxuICovXG5cbi8qKlxuICogYERhdGFPbmx5PFQ+YCBtZWFucyB0byByZXR1cm4gYSByZWNvcmQgdHlwZSBgVDJgIGNvbnNpc3Rpbmcgb25seSBvZlxuICogcHJvcGVydGllcyB0aGF0IGFyZSAqbm90KiBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgdG8gYmUgZmlsdGVyZWQuXG4gKiBAdHlwZWRlZiB7T21pdDxULCBGaWx0ZXJlZEtleXM8VCwgSU1QT1JUKCcuL3R5cGVzLmpzJykuQ2FsbGFibGU+Pn0gRGF0YU9ubHlcbiAqL1xuXG4vKipcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMzEzOTR9XG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1Byb21pc2VMaWtlPFQ+IHwgVH0gRVJlZlxuICogRGVjbGFyZSB0aGF0IGBUYCBtYXkgb3IgbWF5IG5vdCBiZSBhIFByb21pc2UuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yXG4gKiBjb25zdW1lcnMgb2YgYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHJldHVybiB2YWx1ZXMgc2hvdWxkIHNwZWNpZmljYWxseSBiZVxuICogYFByb21pc2U8VD5gIG9yIGBUYCBpdHNlbGYuXG4gKi9cblxuLyoqXG4gKiBUaGUgYXdhaXRlZCByZXR1cm4gdHlwZSBvZiBhIGZ1bmN0aW9uLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgKC4uLmFyZ3M6IGFueVtdKSA9PiBpbmZlciBSID8gQXdhaXRlZDxSPiA6IG5ldmVyfSBFUmV0dXJuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBSZXR1cm5UeXBlPFQ+IGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT4gICAgICAgICAgICAgICAgICAgICAgIC8vIGlmIGZ1bmN0aW9uIHJldHVybnMgYSBwcm9taXNlXG4gKiAgICAgPyBUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIHRoZSBmdW5jdGlvblxuICogICAgIDogKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8RVJldHVybjxUPj4gIC8vIG1ha2UgaXQgcmV0dXJuIGEgcHJvbWlzZVxuICogKX0gRUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRUNhbGxhYmxlPFRbUF0+XG4gKiAgICAgOiBuZXZlcjtcbiAqIH19IEVNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPlxuICogICAgID8gVFtQXVxuICogICAgIDogUHJvbWlzZTxBd2FpdGVkPFRbUF0+PjtcbiAqIH19IEVHZXR0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8dm9pZD59IEVTZW5kT25seUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VFtQXT5cbiAqICAgICA6IG5ldmVyO1xuICogfX0gRVNlbmRPbmx5TWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VD4gJiBFU2VuZE9ubHlNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogICAgIDogRVNlbmRPbmx5TWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICl9IEVTZW5kT25seUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyBFQ2FsbGFibGU8VD4gJiBFTWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICAgICA6IEVNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogKX0gRUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBSZXR1cm4gYSB1bmlvbiBvZiBwcm9wZXJ0eSBuYW1lcy9zeW1ib2xzL251bWJlcnMgUCBmb3Igd2hpY2ggdGhlIHJlY29yZCBlbGVtZW50IFRbUF0ncyB0eXBlIGV4dGVuZHMgVS5cbiAqXG4gKiBHaXZlbiBjb25zdCB4ID0geyBhOiAxMjMsIGI6ICdoZWxsbycsIGM6IDQyLCA0OTogKCkgPT4ge30sIDUzOiA2NyB9LFxuICpcbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgbnVtYmVyPiBpcyB0aGUgdHlwZSAnYScgfCAnYycgfCA1My5cbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgc3RyaW5nPiBpcyB0aGUgdHlwZSAnYicuXG4gKiBGaWx0ZXJlZEtleXM8dHlwZW9mIHgsIDQyIHwgNjc+IGlzIHRoZSB0eXBlICdjJyB8IDUzLlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBib29sZWFuPiBpcyB0aGUgdHlwZSBuZXZlci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFVcbiAqIEB0eXBlZGVmIHt7IFtQIGluIGtleW9mIFRdOiBUW1BdIGV4dGVuZHMgVSA/IFAgOiBuZXZlcjsgfVtrZXlvZiBUXX0gRmlsdGVyZWRLZXlzXG4gKi9cblxuLyoqXG4gKiBgUGlja0NhbGxhYmxlPFQ+YCBtZWFucyB0byByZXR1cm4gYSBzaW5nbGUgcm9vdCBjYWxsYWJsZSBvciBhIHJlY29yZCB0eXBlXG4gKiBjb25zaXN0aW5nIG9ubHkgb2YgcHJvcGVydGllcyB0aGF0IGFyZSBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFJldHVyblR5cGU8VD4gICAgICAgICAgICAgICAgICAgICAvLyBhIHJvb3QgY2FsbGFibGUsIG5vIG1ldGhvZHNcbiAqICAgICA6IFBpY2s8VCwgRmlsdGVyZWRLZXlzPFQsIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPj4gICAgICAgICAgLy8gYW55IGNhbGxhYmxlIG1ldGhvZHNcbiAqICl9IFBpY2tDYWxsYWJsZVxuICovXG5cbi8qKlxuICogYFJlbW90ZUZ1bmN0aW9uczxUPmAgbWVhbnMgdG8gcmV0dXJuIHRoZSBmdW5jdGlvbnMgYW5kIHByb3BlcnRpZXMgdGhhdCBhcmUgcmVtb3RlbHkgY2FsbGFibGUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPiAgICAgLy8gaWYgYSBnaXZlbiBUIGlzIHNvbWUgcmVtb3RlIGludGVyZmFjZSBSXG4gKiAgICAgPyBQaWNrQ2FsbGFibGU8Uj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gdGhlIGNhbGxhYmxlIHByb3BlcnRpZXMgb2YgUlxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+IC8vIG90aGVyd2lzZSwgaWYgdGhlIGZpbmFsIHJlc29sdXRpb24gb2YgVCBpcyBzb21lIHJlbW90ZSBpbnRlcmZhY2UgUlxuICogICAgID8gUGlja0NhbGxhYmxlPFI+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIHRoZW4gcmV0dXJuIHRoZSBjYWxsYWJsZSBwcm9wZXJ0aWVzIG9mIFJcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UsIGlmIFQgaXMgYSBwcm9taXNlXG4gKiAgICAgPyBBd2FpdGVkPFQ+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gcmVzb2x2ZWQgdmFsdWUgVFxuICogICAgIDogVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG90aGVyd2lzZSwgcmV0dXJuIFRcbiAqICl9IFJlbW90ZUZ1bmN0aW9uc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPlxuICogICAgID8gTFxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+XG4gKiAgICAgPyBMXG4gKiAgICAgOiBUIGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT5cbiAqICAgICA/IEF3YWl0ZWQ8VD5cbiAqICAgICA6IFRcbiAqICl9IExvY2FsUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1IgPSB1bmtub3duXVxuICogQHR5cGVkZWYge3tcbiAqICAgcHJvbWlzZTogUHJvbWlzZTxSPjtcbiAqICAgc2V0dGxlcjogSU1QT1JUKCcuL3R5cGVzLmpzJykuU2V0dGxlcjxSPjtcbiAqIH19IEVQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBEZWNsYXJlIGEgbmVhciBvYmplY3QgdGhhdCBtdXN0IG9ubHkgYmUgaW52b2tlZCB3aXRoIEUsIGV2ZW4gbG9jYWxseS4gIEl0XG4gKiBzdXBwb3J0cyB0aGUgYFRgIGludGVyZmFjZSBidXQgYWRkaXRpb25hbGx5IHBlcm1pdHMgYFRgJ3MgbWV0aG9kcyB0byByZXR1cm5cbiAqIGBQcm9taXNlTGlrZWBzIGV2ZW4gaWYgYFRgIGRlY2xhcmVzIHRoZW0gYXMgb25seSBzeW5jaHJvbm91cy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VD4+Pj5cbiAqICAgICA6IFQgZXh0ZW5kcyBSZWNvcmQ8UHJvcGVydHlLZXksIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPlxuICogICAgID8ge1xuICogICAgICAgICBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgICAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUW0tdPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VFtLXT4+Pj5cbiAqICAgICAgICAgICA6IFRbS107XG4gKiAgICAgICB9XG4gKiAgICAgOiBUXG4gKiApfSBFT25seVxuICovJGjNj19vbmNlLmRlZmF1bHQoJGPNj19kZWZhdWx0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2V4cG9ydHMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG2wnmyYEQAAmBEAACcAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanN7ImltcG9ydHMiOlsiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOlsiZ2V0TWV0aG9kTmFtZXMiLCJsb2NhbEFwcGx5RnVuY3Rpb24iLCJsb2NhbEFwcGx5TWV0aG9kIiwibG9jYWxHZXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyOyRozY9faW1wb3J0cyhbW1wiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzXCIsIFtbXCJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcIiwgWyRozY9fYSA9PiAobWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyID0gJGjNj19hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzLGdldFByb3RvdHlwZU9mLGZyZWV6ZX09T2JqZWN0O1xuY29uc3R7YXBwbHksb3duS2V5c309UmVmbGVjdDtcblxuY29uc3QgbnR5cGVvZj0oc3BlY2ltZW4pPT5zcGVjaW1lbj09PW51bGw/J251bGwnOnR5cGVvZiBzcGVjaW1lbjtcblxuY29uc3Qgb25EZWxpdmVyeT1tYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIoJ0VORE9fREVMSVZFUllfQlJFQUtQT0lOVFMnKTtcblxuLyoqXG4gKiBUT0RPIENvbnNvbGlkYXRlIHdpdGggYGlzT2JqZWN0YCB0aGF0J3MgY3VycmVudGx5IGluIGBAZW5kby9tYXJzaGFsYFxuICpcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7XG5cbi8qKlxuICogUHJpb3JpdGl6ZSBzeW1ib2xzIGFzIGVhcmxpZXIgdGhhbiBzdHJpbmdzLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0gYVxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBiXG4gKiBAcmV0dXJucyB7LTEgfCAwIHwgMX1cbiAqL1xuY29uc3QgY29tcGFyZVN0cmluZ2lmaWVkPShhLGIpPT57XG5pZih0eXBlb2YgYT09PXR5cGVvZiBiKXtcbmNvbnN0IGxlZnQ9U3RyaW5nKGEpO1xuY29uc3QgcmlnaHQ9U3RyaW5nKGIpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLW5lc3RlZC10ZXJuYXJ5Ki9cbnJldHVybiBsZWZ0PHJpZ2h0Py0xOmxlZnQ+cmlnaHQ/MTowO1xuIH1cbmlmKHR5cGVvZiBhPT09J3N5bWJvbCcpe1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N0cmluZycpO1xucmV0dXJuLTE7XG4gfVxuYXNzZXJ0KHR5cGVvZiBhPT09J3N0cmluZycpO1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N5bWJvbCcpO1xucmV0dXJuIDE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGRlc2NzKSl7XG4vKiBJbiBjYXNlIGEgbWV0aG9kIGlzIG92ZXJyaWRkZW4gYnkgYSBub24tbWV0aG9kLCovXG4vKiB0ZXN0IGB2YWxbbmFtZV1gIHJhdGhlciB0aGFuIGBsYXllcltuYW1lXWAqL1xuaWYodHlwZW9mIHZhbFtuYW1lXT09PSdmdW5jdGlvbicpe1xubmFtZXMuYWRkKG5hbWUpO1xuIH1cbiB9XG5pZighaXNPYmplY3QodmFsKSl7XG5icmVhaztcbiB9XG5sYXllcj1nZXRQcm90b3R5cGVPZihsYXllcik7XG4gfVxucmV0dXJuIGhhcmRlbihbLi4ubmFtZXNdLnNvcnQoY29tcGFyZVN0cmluZ2lmaWVkKSk7XG4gfTtcbi8qIFRoZSB0b3AgbGV2ZWwgb2YgdGhlIGV2ZW50dWFsIHNlbmQgbW9kdWxlcyBjYW4gYmUgZXZhbHVhdGVkIGJlZm9yZSovXG4vKiBzZXMgY3JlYXRlcyBgaGFyZGVuYCwgYW5kIHNvIGNhbm5vdCByZWx5IG9uIGBoYXJkZW5gIGF0IHRvcCBsZXZlbC4qLyRozY9fb25jZS5nZXRNZXRob2ROYW1lcyhnZXRNZXRob2ROYW1lcyk7XG5mcmVlemUoZ2V0TWV0aG9kTmFtZXMpO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseUZ1bmN0aW9uPShyZWNpcGllbnQsYXJncyk9PntcbnR5cGVvZiByZWNpcGllbnQ9PT0nZnVuY3Rpb24nfHxcbmFzc2VydC5mYWlsKFxuWCBgQ2Fubm90IGludm9rZSB0YXJnZXQgYXMgYSBmdW5jdGlvbjsgdHlwZW9mIHRhcmdldCBpcyAke3EoXG5udHlwZW9mKHJlY2lwaWVudCkpXG4gfWAsXG5UeXBlRXJyb3IpO1xuXG5pZihvbkRlbGl2ZXJ5JiZvbkRlbGl2ZXJ5LnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIFNURVAgSU5UTyBBUFBMWSovXG4vKiBTdG9wcGVkIGF0IGEgYnJlYWtwb2ludCBvbiB0aGlzIGRlbGl2ZXJ5IG9mIGFuIGV2ZW50dWFsIGZ1bmN0aW9uIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIGZ1bmN0aW9uIGNhbGwgYXMgaXQgaGFwcGVucy4gT3Igc3RlcCAqb3ZlciogdG8gc2VlIHdoYXQgaGFwcGVucyovXG4vKiBhZnRlciB0aGUgZnVuY3Rpb24gY2FsbCByZXR1cm5zLiovXG4gfVxuY29uc3QgcmVzdWx0PWFwcGx5KHJlY2lwaWVudCx1bmRlZmluZWQsYXJncyk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjNj19vbmNlLmxvY2FsQXBwbHlGdW5jdGlvbihsb2NhbEFwcGx5RnVuY3Rpb24pO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseU1ldGhvZD0ocmVjaXBpZW50LG1ldGhvZE5hbWUsYXJncyk9PntcbmlmKG1ldGhvZE5hbWU9PT11bmRlZmluZWR8fG1ldGhvZE5hbWU9PT1udWxsKXtcbi8qIEJhc2UgY2FzZTsgYm90dG9tIG91dCB0byBhcHBseSBmdW5jdGlvbnMuKi9cbnJldHVybiBsb2NhbEFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ3MpO1xuIH1cbmlmKHJlY2lwaWVudD09PXVuZGVmaW5lZHx8cmVjaXBpZW50PT09bnVsbCl7XG5hc3NlcnQuZmFpbChcblggYENhbm5vdCBkZWxpdmVyICR7cShtZXRob2ROYW1lKX0gdG8gdGFyZ2V0OyB0eXBlb2YgdGFyZ2V0IGlzICR7cShcbm50eXBlb2YocmVjaXBpZW50KSlcbiB9YCxcblR5cGVFcnJvcik7XG5cbiB9XG5jb25zdCBmbj1yZWNpcGllbnRbbWV0aG9kTmFtZV07XG5pZihmbj09PXVuZGVmaW5lZCl7XG5hc3NlcnQuZmFpbChcblggYHRhcmdldCBoYXMgbm8gbWV0aG9kICR7cShtZXRob2ROYW1lKX0sIGhhcyAke3EoXG5nZXRNZXRob2ROYW1lcyhyZWNpcGllbnQpKVxuIH1gLFxuVHlwZUVycm9yKTtcblxuIH1cbmNvbnN0IGZ0eXBlPW50eXBlb2YoZm4pO1xudHlwZW9mIGZuPT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBpbnZva2VkIG1ldGhvZCAke3EobWV0aG9kTmFtZSl9IGlzIG5vdCBhIGZ1bmN0aW9uOyBpdCBpcyBhICR7cShcbmZ0eXBlKVxuIH1gO1xuaWYob25EZWxpdmVyeSYmb25EZWxpdmVyeS5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxtZXRob2ROYW1lKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogU1RFUCBJTlRPIEFQUExZKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIHRoaXMgZGVsaXZlcnkgb2YgYW4gZXZlbnR1YWwgbWV0aG9kIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIG1ldGhvZCBjYWxsIGFzIGl0IGhhcHBlbnMuIE9yIHN0ZXAgKm92ZXIqIHRvIHNlZSB3aGF0IGhhcHBlbnMqL1xuLyogYWZ0ZXIgdGhlIG1ldGhvZCBjYWxsIHJldHVybnMuKi9cbiB9XG5jb25zdCByZXN1bHQ9YXBwbHkoZm4scmVjaXBpZW50LGFyZ3MpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRozY9fb25jZS5sb2NhbEFwcGx5TWV0aG9kKGxvY2FsQXBwbHlNZXRob2QpO1xuXG5jb25zdCAgICAgICAgbG9jYWxHZXQ9KHQsa2V5KT0+dFtrZXldOyRozY9fb25jZS5sb2NhbEdldChsb2NhbEdldCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJsb2NhbEFwcGx5RnVuY3Rpb24iOlsibG9jYWxBcHBseUZ1bmN0aW9uIl0sImxvY2FsQXBwbHlNZXRob2QiOlsibG9jYWxBcHBseU1ldGhvZCJdLCJsb2NhbEdldCI6WyJsb2NhbEdldCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABt8TAWoRYAAKEWAAA1AAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgZ2V0RW52aXJvbm1lbnRPcHRpb247JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuY29uc3R7aGFzT3duLGZyZWV6ZSxlbnRyaWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZyB8ICcqJ30gTWF0Y2hTdHJpbmdUYWdcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IHJlY2lwaWVudC4gT3RoZXJ3aXNlLCB0aGUgc3RyaW5nIGlzXG4gKiAgIG1hdGNoZWQgYWdhaW5zdCB0aGUgdmFsdWUgb2YgYSByZWNpcGllbnQncyBgQEB0b1N0cmluZ1RhZ2BcbiAqICAgYWZ0ZXIgc3RyaXBwaW5nIG91dCBhbnkgbGVhZGluZyBgJ0FsbGVnZWQ6ICdgIG9yIGAnRGVidWdOYW1lOiAnYFxuICogICBwcmVmaXguIEZvciBvYmplY3RzIGRlZmluZWQgd2l0aCBgRmFyYCB0aGlzIGlzIHRoZSBmaXJzdCBhcmd1bWVudCxcbiAqICAga25vd24gYXMgdGhlIGBmYXJOYW1lYC4gRm9yIGV4b3MsIHRoaXMgaXMgdGhlIHRhZy5cbiAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgJyonfSBNYXRjaE1ldGhvZE5hbWVcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IG1ldGhvZCBuYW1lLiBPdGhlcndpc2UsIHRoZSBzdHJpbmcgaXNcbiAqICAgbWF0Y2hlZCBhZ2FpbnN0IHRoZSBtZXRob2QgbmFtZS4gQ3VycmVudGx5LCB0aGlzIGlzIG9ubHkgYW4gZXhhY3QgbWF0Y2guXG4gKiAgIEhvd2V2ZXIsIGJld2FyZSB0aGF0IHdlIG1heSBpbnRyb2R1Y2UgYSBzdHJpbmcgc3ludGF4IGZvclxuICogICBzeW1ib2wgbWV0aG9kIG5hbWVzLlxuICovXG4vKipcbiAqIEB0eXBlZGVmIHtudW1iZXIgfCAnKid9IE1hdGNoQ291bnRkb3duXG4gKiAgIEEgc3RhciBgJyonYCB3aWxsIGFsd2F5cyBicmVha3BvaW50LiBPdGhlcndpc2UsIHRoZSBzdHJpbmdcbiAqICAgbXVzdCBiZSBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyLiBPbmNlIHRoYXQgaXMgemVybywgYWx3YXlzIGJyZWFrcG9pbnQuXG4gKiAgIE90aGVyd2lzZSBkZWNyZW1lbnQgYnkgb25lIGVhY2ggdGltZSBpdCBtYXRjaGVzIHVudGlsIGl0IHJlYWNoZXMgemVyby5cbiAqICAgSW4gb3RoZXIgd29yZHMsIHRoZSBjb3VudGRvd24gcmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mXG4gKiAgIGJyZWFrcG9pbnQgb2NjdXJyZW5jZXMgdG8gc2tpcCBiZWZvcmUgYWN0dWFsbHkgYnJlYWtwb2ludGluZy5cbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIGV4dGVybmFsIEpTT04gcmVwcmVzZW50YXRpb24sIGluIHdoaWNoXG4gKiAtIHRoZSBvdXRlciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBjbGFzcy1saWtlIHRhZyBvciAnKicsXG4gKiAtIHRoZSBpbm5lciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBtZXRob2QgbmFtZSBvciAnKicsXG4gKiAtIHRoZSB2YWx1ZSBpcyBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyIGNvdW50ZG93biBvciAnKicuXG4gKlxuICogQHR5cGVkZWYge1JlY29yZDxNYXRjaFN0cmluZ1RhZywgUmVjb3JkPE1hdGNoTWV0aG9kTmFtZSwgTWF0Y2hDb3VudGRvd24+Pn0gTWVzc2FnZUJyZWFrcG9pbnRzXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBpbnRlcm5hbCBKU09OIHJlcHJlc2VudGF0aW9uLCBpbiB3aGljaFxuICogLSB0aGUgb3V0ZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgbWV0aG9kIG5hbWUgb3IgJyonLFxuICogLSB0aGUgaW5uZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgY2xhc3MtbGlrZSB0YWcgb3IgJyonLFxuICogLSB0aGUgdmFsdWUgaXMgYSBub24tbmVnYXRpdmUgaW50ZWdlciBjb3VudGRvd24gb3IgJyonLlxuICpcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8TWF0Y2hNZXRob2ROYW1lLCBSZWNvcmQ8TWF0Y2hTdHJpbmdUYWcsIE1hdGNoQ291bnRkb3duPj59IEJyZWFrcG9pbnRUYWJsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gTWVzc2FnZUJyZWFrcG9pbnRzfSBnZXRCcmVha3BvaW50c1xuICogQHByb3BlcnR5IHsobmV3QnJlYWtwb2ludHM/OiBNZXNzYWdlQnJlYWtwb2ludHMpID0+IHZvaWR9IHNldEJyZWFrcG9pbnRzXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVjaXBpZW50OiBvYmplY3QsXG4gKiAgIG1ldGhvZE5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IHVuZGVmaW5lZFxuICogKSA9PiBib29sZWFufSBzaG91bGRCcmVha3BvaW50XG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7dmFsIGlzIFJlY29yZDxzdHJpbmcsIGFueT59XG4gKi9cbmNvbnN0IGlzSlNPTlJlY29yZD0odmFsKT0+XG50eXBlb2YgdmFsPT09J29iamVjdCcmJnZhbCE9PW51bGwmJiFBcnJheS5pc0FycmF5KHZhbCk7XG5cbi8qKlxuICogUmV0dXJuIGB0YWdgIGFmdGVyIHN0cmlwcGluZyBvZmYgYW55IGAnQWxsZWdlZDogJ2Agb3IgYCdEZWJ1Z05hbWU6ICdgXG4gKiBwcmVmaXggaWYgcHJlc2VudC5cbiAqIGBgYGpzXG4gKiBzaW1wbGlmeVRhZygnQWxsZWdlZDogbW9vbGEgaXNzdWVyJykgPT09ICdtb29sYSBpc3N1ZXInXG4gKiBgYGBcbiAqIElmIHRoZXJlIGFyZSBtdWx0aXBsZSBzdWNoIHByZWZpeGVzLCBvbmx5IHRoZSBvdXRlciBvbmUgaXMgcmVtb3ZlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBzaW1wbGlmeVRhZz0odGFnKT0+e1xuZm9yKGNvbnN0IHByZWZpeCBvZlsnQWxsZWdlZDogJywnRGVidWdOYW1lOiAnXSl7XG5pZih0YWcuc3RhcnRzV2l0aChwcmVmaXgpKXtcbnJldHVybiB0YWcuc2xpY2UocHJlZml4Lmxlbmd0aCk7XG4gfVxuIH1cbnJldHVybiB0YWc7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge01lc3NhZ2VCcmVha3BvaW50VGVzdGVyIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCAgICAgICAgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyPShvcHRpb25OYW1lKT0+e1xubGV0IGJyZWFrcG9pbnRzPUpTT04ucGFyc2UoZ2V0RW52aXJvbm1lbnRPcHRpb24ob3B0aW9uTmFtZSwnbnVsbCcpKTtcblxuaWYoYnJlYWtwb2ludHM9PT1udWxsKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbmxldCBicmVha3BvaW50c1RhYmxlO1xuXG5jb25zdCBnZXRCcmVha3BvaW50cz0oKT0+YnJlYWtwb2ludHM7XG5mcmVlemUoZ2V0QnJlYWtwb2ludHMpO1xuXG5jb25zdCBzZXRCcmVha3BvaW50cz0obmV3QnJlYWtwb2ludHM9YnJlYWtwb2ludHMpPT57XG5pc0pTT05SZWNvcmQobmV3QnJlYWtwb2ludHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uIHRvIGJlIGEgSlNPTiBicmVha3BvaW50cyByZWNvcmRgO1xuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbmNvbnN0IG5ld0JyZWFrcG9pbnRzVGFibGU9e19fcHJvdG9fXzpudWxsfTtcblxuZm9yKGNvbnN0W3RhZyxtZXRob2RCUHNdb2YgZW50cmllcyhuZXdCcmVha3BvaW50cykpe1xudGFnPT09c2ltcGxpZnlUYWcodGFnKXx8XG5GYWlsIGBKdXN0IHVzZSBzaW1wbGUgdGFnICR7cShzaW1wbGlmeVRhZyh0YWcpKX0gcmF0aGVyIHRoYW4gJHtxKHRhZyl9YDtcbmlzSlNPTlJlY29yZChtZXRob2RCUHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uJ3MgJHtxKFxudGFnKVxuIH0gdG8gYmUgYSBKU09OIG1ldGhvZHMgYnJlYWtwb2ludHMgcmVjb3JkYDtcbmZvcihjb25zdFttZXRob2ROYW1lLGNvdW50XW9mIGVudHJpZXMobWV0aG9kQlBzKSl7XG5jb3VudD09PScqJ3x8XG50eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmXG5OdW1iZXIuaXNTYWZlSW50ZWdlcihjb3VudCkmJlxuY291bnQ+PTB8fFxuRmFpbCBgRXhwZWN0ZWQgJHtxKG9wdGlvbk5hbWUpfSBvcHRpb24ncyAke3EodGFnKX0uJHtxKFxubWV0aG9kTmFtZSlcbiB9IHRvIGJlIFwiKlwiIG9yIGEgbm9uLW5lZ2F0aXZlIGludGVnZXJgO1xuXG5jb25zdCBjbGFzc0JQcz1oYXNPd24obmV3QnJlYWtwb2ludHNUYWJsZSxtZXRob2ROYW1lKT9cbm5ld0JyZWFrcG9pbnRzVGFibGVbbWV0aG9kTmFtZV06XG5uZXdCcmVha3BvaW50c1RhYmxlW21ldGhvZE5hbWVdPXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbl9fcHJvdG9fXzpudWxsfTtcblxuY2xhc3NCUHNbdGFnXT1jb3VudDtcbiB9XG4gfVxuYnJlYWtwb2ludHM9bmV3QnJlYWtwb2ludHM7XG5icmVha3BvaW50c1RhYmxlPW5ld0JyZWFrcG9pbnRzVGFibGU7XG4gfTtcbmZyZWV6ZShzZXRCcmVha3BvaW50cyk7XG5cbmNvbnN0IHNob3VsZEJyZWFrcG9pbnQ9KHJlY2lwaWVudCxtZXRob2ROYW1lKT0+e1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZHx8bWV0aG9kTmFtZT09PW51bGwpe1xuLyogVE9ETyBlbmFibGUgZnVuY3Rpb24gYnJlYWtwb2ludGluZyovXG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgY2xhc3NCUHM9YnJlYWtwb2ludHNUYWJsZVttZXRob2ROYW1lXXx8YnJlYWtwb2ludHNUYWJsZVsnKiddO1xuaWYoY2xhc3NCUHM9PT11bmRlZmluZWQpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmxldCB0YWc9c2ltcGxpZnlUYWcocmVjaXBpZW50W1N5bWJvbC50b1N0cmluZ1RhZ10pO1xubGV0IGNvdW50PWNsYXNzQlBzW3RhZ107XG5pZihjb3VudD09PXVuZGVmaW5lZCl7XG50YWc9JyonO1xuY291bnQ9Y2xhc3NCUHNbdGFnXTtcbmlmKGNvdW50PT09dW5kZWZpbmVkKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuaWYoY291bnQ9PT0nKicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoY291bnQ9PT0wKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydCh0eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmY291bnQ+PTEpO1xuY2xhc3NCUHNbdGFnXT1jb3VudC0xO1xucmV0dXJuIGZhbHNlO1xuIH07XG5mcmVlemUoc2hvdWxkQnJlYWtwb2ludCk7XG5cbmNvbnN0IGJyZWFrcG9pbnRUZXN0ZXI9ZnJlZXplKHtcbmdldEJyZWFrcG9pbnRzLFxuc2V0QnJlYWtwb2ludHMsXG5zaG91bGRCcmVha3BvaW50fSk7XG5cbmJyZWFrcG9pbnRUZXN0ZXIuc2V0QnJlYWtwb2ludHMoKTtcbnJldHVybiBicmVha3BvaW50VGVzdGVyO1xuIH07JGjNj19vbmNlLm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlcihtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIpO1xuZnJlZXplKG1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3Rlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiOlsibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABeEUwx5AwAAeQMAACkAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbm8tc2hpbS5qc3siaW1wb3J0cyI6WyIuL0UuanMiLCIuL2V4cG9ydHMuanMiXSwiZXhwb3J0cyI6WyJFIiwiSGFuZGxlZFByb21pc2UiXSwicmVleHBvcnRzIjpbIi4vZXhwb3J0cy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBtYWtlRTskaM2PX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbW1wiZGVmYXVsdFwiLCBbJGjNj19hID0+IChtYWtlRSA9ICRozY9fYSldXV1dLFtcIi4vZXhwb3J0cy5qc1wiLCBbXV1dKTsgICBcblxuLyogWFhYIG1vZHVsZSBleHBvcnRzIGZvciBIYW5kbGVkUHJvbWlzZSBmYWlsIGlmIHRoZXNlIGFyZW4ndCBpbiBzY29wZSovXG4vKiogQGltcG9ydCB7SGFuZGxlciwgSGFuZGxlZEV4ZWN1dG9yfSBmcm9tICcuL2hhbmRsZWQtcHJvbWlzZS5qcycgKi9cbi8qKiBAaW1wb3J0IHtFQ2FsbGFibGVPck1ldGhvZHMsIEVHZXR0ZXJzLCBFUmVmLCBFUmVtb3RlRnVuY3Rpb25zLCBFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kcywgTG9jYWxSZWNvcmQsIFJlbW90ZUZ1bmN0aW9uc30gZnJvbSAnLi9FLmpzJyAqL1xuXG5jb25zdCBocD1IYW5kbGVkUHJvbWlzZTskaM2PX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoaHApOyRozY9fb25jZS5FKEUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiSGFuZGxlZFByb21pc2UiOlsiaHAiXSwiRSI6WyJFIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB6458vtEAAA7RAAAC0AAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJ0cmFja1R1cm5zIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLGVudmlyb25tZW50T3B0aW9uc0xpc3RIYXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV0sW1wiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhc1wiLCBbJGjNj19hID0+IChlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIFdlIGFsc28gY2Fubm90IGN1cnJlbnRseSBpbXBvcnQgdGhlbSBiZWNhdXNlIGl0IHdvdWxkIGNyZWF0ZSBhIGN5Y2xpYyovXG4vKiBkZXBlbmRlbmN5LCB0aG91Z2ggdGhpcyBpcyBtb3JlIGVhc2lseSBmaXhlZC4qL1xuLyogaW1wb3J0IHsgYXNzZXJ0LCBYLCBGYWlsIH0gZnJvbSAnQGVuZG8vZXJyb3JzJzsqL1xuLyogU2VlIGFsc28gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85NTE1Ki9cblxuLyogV0FSTklORzogR2xvYmFsIE11dGFibGUgU3RhdGUhKi9cbi8qIFRoaXMgc3RhdGUgaXMgY29tbXVuaWNhdGVkIHRvIGBhc3NlcnRgIHRoYXQgbWFrZXMgaXQgYXZhaWxhYmxlIHRvIHRoZSovXG4vKiBjYXVzYWwgY29uc29sZSwgd2hpY2ggYWZmZWN0cyB0aGUgY29uc29sZSBsb2cgb3V0cHV0LiBOb3JtYWxseSB3ZSovXG4vKiByZWdhcmQgdGhlIGFiaWxpdHkgdG8gc2VlIGNvbnNvbGUgbG9nIG91dHB1dCBhcyBhIG1ldGEtbGV2ZWwgcHJpdmlsZWdlKi9cbi8qIGFuYWxvZ291cyB0byB0aGUgYWJpbGl0eSB0byBkZWJ1Zy4gQXNpZGUgZnJvbSB0aGF0LCB0aGlzIG1vZHVsZSBzaG91bGQqL1xuLyogbm90IGhhdmUgYW55IG9ic2VydmFibHkgbXV0YWJsZSBzdGF0ZS4qL1xuXG5sZXQgaGlkZGVuUHJpb3JFcnJvcjtcbmxldCBoaWRkZW5DdXJyZW50VHVybj0wO1xubGV0IGhpZGRlbkN1cnJlbnRFdmVudD0wO1xuXG4vKiBUdXJuIG9uIGlmIHlvdSBzZWVtIHRvIGJlIGxvc2luZyBlcnJvciBsb2dnaW5nIGF0IHRoZSB0b3Agb2YgdGhlIGV2ZW50IGxvb3AqL1xuY29uc3QgVkVSQk9TRT1lbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKCdERUJVRycsJ3RyYWNrLXR1cm5zJyk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBlbmFibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgRU5BQkxFRD1cbmdldEVudmlyb25tZW50T3B0aW9uKCdUUkFDS19UVVJOUycsJ2Rpc2FibGVkJyxbJ2VuYWJsZWQnXSk9PT0nZW5hYmxlZCc7XG5cbi8qIFdlIGhvaXN0IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIG91dCBvZiB0cmFja1R1cm5zKCkgdG8gZGlzY291cmFnZSB0aGUqL1xuLyogY2xvc3VyZXMgZnJvbSBob2xkaW5nIG9udG8gJ2FyZ3MnIG9yICdmdW5jJyBsb25nZXIgdGhhbiBuZWNlc3NhcnksKi9cbi8qIHdoaWNoIHdlJ3ZlIHNlZW4gY2F1c2UgSGFuZGxlZFByb21pc2UgYXJndW1lbnRzIHRvIGJlIHJldGFpbmVkIGZvciovXG4vKiBhIHN1cnByaXNpbmdseSBsb25nIHRpbWUuKi9cblxuY29uc3QgYWRkUmVqZWN0aW9uTm90ZT0oZGV0YWlsc05vdGUpPT4ocmVhc29uKT0+e1xuaWYocmVhc29uIGluc3RhbmNlb2YgRXJyb3Ipe1xuZ2xvYmFsVGhpcy5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9O1xuXG5jb25zdCB3cmFwRnVuY3Rpb249XG4oZnVuYyxzZW5kaW5nRXJyb3IsWCk9PlxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5nbG9iYWxUaGlzLmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goYWRkUmVqZWN0aW9uTm90ZShkZXRhaWxzTm90ZSkpO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9O1xuXG4vKipcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAdGVtcGxhdGUge1R1cm5TdGFydGVyRm5bXX0gVFxuICogQHBhcmFtIHtUfSBmdW5jc1xuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICB0cmFja1R1cm5zPShmdW5jcyk9PntcbmlmKCFFTkFCTEVEfHx0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WCxub3RlOmFubm90YXRlRXJyb3J9PWdsb2JhbFRoaXMuYXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9RXJyb3IoXG4gYEV2ZW50OiAke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuaWYoaGlkZGVuUHJpb3JFcnJvciE9PXVuZGVmaW5lZCl7XG5hbm5vdGF0ZUVycm9yKHNlbmRpbmdFcnJvcixYIGBDYXVzZWQgYnk6ICR7aGlkZGVuUHJpb3JFcnJvcn1gKTtcbiB9XG5cbnJldHVybiAoLyoqIEB0eXBlIHtUfSAqL1xuZnVuY3MubWFwKChmdW5jKT0+ZnVuYyYmd3JhcEZ1bmN0aW9uKGZ1bmMsc2VuZGluZ0Vycm9yLFgpKSk7XG5cbiB9O1xuXG4vKipcbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICpcbiAqIEB0eXBlZGVmIHsoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgdW5kZWZpbmVkfSBUdXJuU3RhcnRlckZuXG4gKi8kaM2PX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InRyYWNrVHVybnMiOlsidHJhY2tUdXJucyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA/8Oc6VgIAAFYCAAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvdXRpbHMuanN7ImltcG9ydHMiOlsiLi9zcmMvbG9jYWwuanMiLCIuL3NyYy9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOltudWxsLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvbG9jYWwuanNcIiwgW11dLFtcIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9sb2NhbC5qcyI6W1siZ2V0TWV0aG9kTmFtZXMiLCJnZXRNZXRob2ROYW1lcyJdXSwiLi9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyI6W1sibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIiwibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC4gWnwdAcAAHQHAAAdAAAAQGVuZG8vbWFyc2hhbC12MS42LjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9zcmMvbWFyc2hhbC5qcyIsIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIiwiLi9zcmMvbWFyc2hhbC1qdXN0aW4uanMiLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyIsIi4vc3JjL3JhbmtPcmRlci5qcyIsIi4vc3JjL3R5cGVzLmpzIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImFzc2VydFJhbmtTb3J0ZWQiLCJhc3NlcnRSYW5rU29ydGVkIiwibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIiwicGFyc2UiLCJwYXJzZSIsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW1tcIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtanVzdGluLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvcmFua09yZGVyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbXV1dKTsgICBcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyI6W1siUUNMQVNTIiwiUUNMQVNTIl1dLCIuL3NyYy9tYXJzaGFsLmpzIjpbWyJtYWtlTWFyc2hhbCIsIm1ha2VNYXJzaGFsIl1dLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6W1sic3RyaW5naWZ5Iiwic3RyaW5naWZ5Il0sWyJwYXJzZSIsInBhcnNlIl1dLCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6W1siZGVjb2RlVG9KdXN0aW4iLCJkZWNvZGVUb0p1c3RpbiJdXSwiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOltbIm1ha2VQYXNzYWJsZUtpdCIsIm1ha2VQYXNzYWJsZUtpdCJdLFsibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIl0sWyJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiXSxbImlzRW5jb2RlZFJlbW90YWJsZSIsImlzRW5jb2RlZFJlbW90YWJsZSJdLFsiemVyb1BhZCIsInplcm9QYWQiXSxbInJlY29yZE5hbWVzIiwicmVjb3JkTmFtZXMiXSxbInJlY29yZFZhbHVlcyIsInJlY29yZFZhbHVlcyJdXSwiLi9zcmMvcmFua09yZGVyLmpzIjpbWyJ0cml2aWFsQ29tcGFyYXRvciIsInRyaXZpYWxDb21wYXJhdG9yIl0sWyJhc3NlcnRSYW5rU29ydGVkIiwiYXNzZXJ0UmFua1NvcnRlZCJdLFsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayJdLFsiaXNSYW5rU29ydGVkIiwiaXNSYW5rU29ydGVkIl0sWyJzb3J0QnlSYW5rIiwic29ydEJ5UmFuayJdLFsiY29tcGFyZUFudGlSYW5rIiwiY29tcGFyZUFudGlSYW5rIl0sWyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0Il0sWyJnZXRQYXNzU3R5bGVDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIl0sWyJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaW50ZXJzZWN0UmFua0NvdmVycyJdLFsidW5pb25SYW5rQ292ZXJzIiwidW5pb25SYW5rQ292ZXJzIl1dLCJAZW5kby9wYXNzLXN0eWxlIjpbWyJkZWVwbHlGdWxmaWxsZWQiLCJkZWVwbHlGdWxmaWxsZWQiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlUGFzc2FibGUuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImlzRW5jb2RlZFJlbW90YWJsZSIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsIm1ha2VFbmNvZGVQYXNzYWJsZSIsIm1ha2VQYXNzYWJsZUtpdCIsInBhc3NTdHlsZVByZWZpeGVzIiwicmVjb3JkTmFtZXMiLCJyZWNvcmRWYWx1ZXMiLCJ6ZXJvUGFkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldFRhZyxtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGFzc2VydFJlY29yZCxpc0Vycm9yTGlrZSxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLGIscSxGYWlsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiYXNzZXJ0UmVjb3JkXCIsIFskaM2PX2EgPT4gKGFzc2VydFJlY29yZCA9ICRozY9fYSldXSxbXCJpc0Vycm9yTGlrZVwiLCBbJGjNj19hID0+IChpc0Vycm9yTGlrZSA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcImJcIiwgWyRozY9fYSA9PiAoYiA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtmcm9tRW50cmllcyxpc309T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcblxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnRyb2wtcmVnZXgqL1xuY29uc3QgckMwPS9bXFx4MDAtXFx4MUZdLztcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHN1ZmZpeCBvZiBhIHN0cmluZyBzdGFydGluZyBhdCBhIHBhcnRpY3VsYXIgaW5kZXguXG4gKiBUaGlzIGJvdGggZXhwcmVzc2VzIGludGVudCBhbmQgcG90ZW50aWFsbHkgYXZvaWRzIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODRcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyXG4gKiBAcGFyYW0ge251bWJlcn0gaW5kZXhcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGdldFN1ZmZpeD0oc3RyLGluZGV4KT0+aW5kZXg9PT0wP3N0cjpzdHIuc3Vic3RyaW5nKGluZGV4KTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCwgd2UgaGF2ZSBvbmx5XG4gKiBzdHJpbmctbmFtZWQgb3duIHByb3BlcnRpZXMuIGByZWNvcmROYW1lc2AgcmV0dXJucyB0aG9zZSBuYW1lICpyZXZlcnNlKlxuICogc29ydGVkLCBiZWNhdXNlIHRoYXQncyBob3cgcmVjb3JkcyBhcmUgY29tcGFyZWQsIGVuY29kZWQsIGFuZCBzb3J0ZWQuXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZE5hbWVzPShyZWNvcmQpPT5cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNjAjZGlzY3Vzc2lvbl9yMTAwMzY1NzI0NCovXG4vKiBjb21wYXJlcyB0d28gd2F5cyBvZiByZXZlcnNlIHNvcnRpbmcsIGFuZCBzaG93cyB0aGF0IGAuc29ydCgpLnJldmVyc2UoKWAqL1xuLyogaXMgY3VycmVudGx5IGZhc3RlciBvbiBNb2RkYWJsZSBYUywgd2hpbGUgdGhlIG90aGVyIHdheSwqL1xuLyogYC5zb3J0KHJldmVyc2VDb21wYXJhdG9yKWAsIGlzIGZhc3RlciBvbiB2OC4gV2UgY3VycmVudGx5IGNhcmUgbW9yZSBhYm91dCovXG4vKiBYUyBwZXJmb3JtYW5jZSwgc28gd2UgcmV2ZXJzZSBzb3J0IHVzaW5nIGAuc29ydCgpLnJldmVyc2UoKWAuKi9cbmhhcmRlbigvKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjb3JkKS5zb3J0KCkucmV2ZXJzZSgpKTskaM2PX29uY2UucmVjb3JkTmFtZXMocmVjb3JkTmFtZXMpO1xuaGFyZGVuKHJlY29yZE5hbWVzKTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCBhbmQgYG5hbWVzYCBpcyBgcmVjb3JkTmFtZXMocmVjb3JkKWAsXG4gKiByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcgYXJyYXkgb2YgcHJvcGVydHkgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxUPn0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBuYW1lc1xuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZFZhbHVlcz0ocmVjb3JkLG5hbWVzKT0+XG5oYXJkZW4obmFtZXMubWFwKChuYW1lKT0+cmVjb3JkW25hbWVdKSk7JGjNj19vbmNlLnJlY29yZFZhbHVlcyhyZWNvcmRWYWx1ZXMpO1xuaGFyZGVuKHJlY29yZFZhbHVlcyk7XG5cbmNvbnN0IHplcm9lcz1BcnJheSgxNikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8saSk9PicwJy5yZXBlYXQoaSkpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gblxuICogQHBhcmFtIHtudW1iZXJ9IHNpemVcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICB6ZXJvUGFkPShuLHNpemUpPT57XG5jb25zdCBuU3RyPSBgJHtufWA7XG5jb25zdCBmaWxsTGVuPXNpemUtblN0ci5sZW5ndGg7XG5pZihmaWxsTGVuPT09MClyZXR1cm4gblN0cjtcbmFzc2VydChmaWxsTGVuPjAmJmZpbGxMZW48emVyb2VzLmxlbmd0aCk7XG5yZXR1cm4gYCR7emVyb2VzW2ZpbGxMZW5dfSR7blN0cn1gO1xuIH07JGjNj19vbmNlLnplcm9QYWQoemVyb1BhZCk7XG5oYXJkZW4oemVyb1BhZCk7XG5cbi8qIFRoaXMgaXMgdGhlIEphdmFTY3JpcHQgYW5hbG9nIHRvIGEgQyB1bmlvbjogYSB3YXkgdG8gbWFwIGJldHdlZW4gYSBmbG9hdCBhcyBhKi9cbi8qIG51bWJlciBhbmQgdGhlIGJpdHMgdGhhdCByZXByZXNlbnQgdGhlIGZsb2F0IGFzIGEgYnVmZmVyIGZ1bGwgb2YgYnl0ZXMuICBOb3RlKi9cbi8qIHRoYXQgdGhlIG11dGF0aW9uIG9mIHN0YXRpYyBzdGF0ZSBoZXJlIG1ha2VzIHRoaXMgaW52YWxpZCBKZXNzaWUgY29kZSwgYnV0Ki9cbi8qIGRvaW5nIGl0IHRoaXMgd2F5IHNhdmVzIHRoZSBudWdhdG9yeSBhbmQgZ3JhdHVpdG91cyBhbGxvY2F0aW9ucyB0aGF0IHdvdWxkKi9cbi8qIGhhcHBlbiBldmVyeSB0aW1lIHlvdSBkbyBhIGNvbnZlcnNpb24gLS0gYW5kIGluIHByYWN0aWNhbCB0ZXJtcyBpdCdzIHNhZmUqL1xuLyogYmVjYXVzZSB3ZSBwdXQgdGhlIHZhbHVlIGluIG9uZSBzaWRlIGFuZCB0aGVuIGltbWVkaWF0ZWx5IHRha2UgaXQgb3V0IHRoZSovXG4vKiBvdGhlcjsgdGhlcmUgaXMgbm8gYWN0dWFsIHN0YXRlIHJldGFpbmVkIGluIHRoZSBjbGFzc2ljIHNlbnNlIGFuZCB0aHVzIG5vKi9cbi8qIHJlLWVudHJhbmN5IGlzc3VlLiovXG5jb25zdCBhc051bWJlcj1uZXcgRmxvYXQ2NEFycmF5KDEpO1xuY29uc3QgYXNCaXRzPW5ldyBCaWdVaW50NjRBcnJheShhc051bWJlci5idWZmZXIpO1xuXG4vKiBKYXZhU2NyaXB0IG51bWJlcnMgYXJlIGVuY29kZWQgYnkgb3V0cHV0dGluZyB0aGUgYmFzZS0xNiovXG4vKiByZXByZXNlbnRhdGlvbiBvZiB0aGUgYmluYXJ5IHZhbHVlIG9mIHRoZSB1bmRlcmx5aW5nIElFRUUgZmxvYXRpbmcgcG9pbnQqL1xuLyogcmVwcmVzZW50YXRpb24uICBGb3IgbmVnYXRpdmUgdmFsdWVzLCBhbGwgYml0cyBvZiB0aGlzIHJlcHJlc2VudGF0aW9uIGFyZSovXG4vKiBjb21wbGVtZW50ZWQgcHJpb3IgdG8gdGhlIGJhc2UtMTYgY29udmVyc2lvbiwgd2hpbGUgZm9yIHBvc2l0aXZlIHZhbHVlcywgdGhlKi9cbi8qIHNpZ24gYml0IGlzIGNvbXBsZW1lbnRlZC4gIFRoaXMgZW5zdXJlcyBib3RoIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYmVmb3JlKi9cbi8qIHBvc2l0aXZlIHZhbHVlcyBhbmQgdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgc29ydCBhY2NvcmRpbmcgdG8gdGhlaXIgbmVnYXRpdmUqL1xuLyogbWFnbml0dWRlIHJhdGhlciB0aGFuIHRoZWlyIHBvc2l0aXZlIG1hZ25pdHVkZS4gIFRoaXMgcmVzdWx0cyBpbiBhbiBBU0NJSSovXG4vKiBlbmNvZGluZyB3aG9zZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgaXMgdGhlIHNhbWUgYXMgdGhlIG51bWVyaWMgc29ydCBvcmRlciovXG4vKiBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLiovXG5cbi8qIFRPRE8gQ2hvb3NlIHRoZSBzYW1lIGNhbm9uaWNhbCBOYU4gZW5jb2RpbmcgdGhhdCBjb3NtV2FzbSBhbmQgZXdhc20gY2hvc2UuKi9cbmNvbnN0IENhbm9uaWNhbE5hTkJpdHM9J2ZmZjgwMDAwMDAwMDAwMDAnO1xuXG4vKipcbiAqIEBwYXJhbSB7bnVtYmVyfSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaW5hcnk2ND0obik9Pntcbi8qIE5vcm1hbGl6ZSAtMCB0byAwIGFuZCBOYU4gdG8gYSBjYW5vbmljYWwgZW5jb2RpbmcqL1xuaWYoaXMobiwtMCkpe1xubj0wO1xuIH1lbHNlIGlmKGlzKG4sTmFOKSl7XG5yZXR1cm4gYGYke0Nhbm9uaWNhbE5hTkJpdHN9YDtcbiB9XG5hc051bWJlclswXT1uO1xubGV0IGJpdHM9YXNCaXRzWzBdO1xuaWYobjwwKXtcbmJpdHNePTB4ZmZmZmZmZmZmZmZmZmZmZm47XG4gfWVsc2V7XG5iaXRzXj0weDgwMDAwMDAwMDAwMDAwMDBuO1xuIH1cbnJldHVybiBgZiR7emVyb1BhZChiaXRzLnRvU3RyaW5nKDE2KSwxNil9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGVCaW5hcnk2ND0oZW5jb2RlZCxza2lwPTApPT57XG5lbmNvZGVkLmNoYXJBdChza2lwKT09PSdmJ3x8RmFpbCBgRW5jb2RlZCBudW1iZXIgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IGJpdHM9QmlnSW50KCBgMHgke2dldFN1ZmZpeChlbmNvZGVkLHNraXArMSl9YCk7XG5pZihlbmNvZGVkLmNoYXJBdChza2lwKzEpPCc4Jyl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5hc0JpdHNbMF09Yml0cztcbmNvbnN0IHJlc3VsdD1hc051bWJlclswXTtcbiFpcyhyZXN1bHQsLTApfHxcbkZhaWwgYFVuZXhwZWN0ZWQgbmVnYXRpdmUgemVybzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEVuY29kZSBhIEphdmFTY3JpcHQgYmlnaW50IHVzaW5nIGEgdmFyaWFudCBvZiBFbGlhcyBkZWx0YSBjb2RpbmcsIHdpdGggYW5cbiAqIGluaXRpYWwgY29tcG9uZW50IGZvciB0aGUgbGVuZ3RoIG9mIHRoZSBkaWdpdCBjb3VudCBhcyBhIHVuYXJ5IHN0cmluZywgYVxuICogc2Vjb25kIGNvbXBvbmVudCBmb3IgdGhlIGRlY2ltYWwgZGlnaXQgY291bnQsIGFuZCBhIHRoaXJkIGNvbXBvbmVudCBmb3IgdGhlXG4gKiBkZWNpbWFsIGRpZ2l0cyBwcmVjZWRlZCBieSBhIGdyYXR1aXRvdXMgc2VwYXJhdGluZyBjb2xvbi5cbiAqIFRvIGVuc3VyZSB0aGF0IHRoZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgb2YgZW5jb2RlZCB2YWx1ZXMgbWF0Y2hlcyB0aGVcbiAqIG51bWVyaWMgc29ydCBvcmRlciBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLCB0aGUgY2hhcmFjdGVycyBvZiB0aGUgdW5hcnlcbiAqIHByZWZpeCBhcmUgZGlmZmVyZW50IGZvciBuZWdhdGl2ZSB2YWx1ZXMgKHR5cGUgXCJuXCIgZm9sbG93ZWQgYnkgYW55IG51bWJlciBvZlxuICogXCIjXCJzIFt3aGljaCBzb3J0IGJlZm9yZSBkZWNpbWFsIGRpZ2l0c10pIHZzLiBwb3NpdGl2ZSBhbmQgemVybyB2YWx1ZXMgKHR5cGVcbiAqIFwicFwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2YgXCJ+XCJzIFt3aGljaCBzb3J0IGFmdGVyIGRlY2ltYWwgZGlnaXRzXSkgYW5kXG4gKiBlYWNoIGRlY2ltYWwgZGlnaXQgb2YgdGhlIGVuY29kaW5nIGZvciBhIG5lZ2F0aXZlIHZhbHVlIGlzIHJlcGxhY2VkIHdpdGggaXRzXG4gKiB0ZW4ncyBjb21wbGVtZW50IChzbyB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBvZiB0aGUgc2FtZSBzY2FsZSBzb3J0IGJ5XG4gKiAqZGVzY2VuZGluZyogYWJzb2x1dGUgdmFsdWUpLlxuICpcbiAqIEBwYXJhbSB7YmlnaW50fSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaWdJbnQ9KG4pPT57XG5jb25zdCBhYnM9bjwwbj8tbjpuO1xuY29uc3QgbkRpZ2l0cz1hYnMudG9TdHJpbmcoKS5sZW5ndGg7XG5jb25zdCBsRGlnaXRzPW5EaWdpdHMudG9TdHJpbmcoKS5sZW5ndGg7XG5pZihuPDBuKXtcbnJldHVybiBgbiR7XG4vKiBBIFwiI1wiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJyMnLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgY291bnQgb2YgZGlnaXRzLiovXG4oMTAqKmxEaWdpdHMtbkRpZ2l0cykudG9TdHJpbmcoKS5wYWRTdGFydChsRGlnaXRzLCcwJylcbiB9OiR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgZGlnaXRzLiovXG4oMTBuKipCaWdJbnQobkRpZ2l0cykrbikudG9TdHJpbmcoKS5wYWRTdGFydChuRGlnaXRzLCcwJylcbiB9YDtcbiB9ZWxzZXtcbnJldHVybiBgcCR7XG4vKiBBIFwiflwiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJ34nLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgY291bnQgb2YgZGlnaXRzLiovXG5uRGlnaXRzXG4gfToke1xuLyogVGhlIGRpZ2l0cy4qL1xublxuIH1gO1xuIH1cbiB9O1xuXG5jb25zdCByQmlnSW50UGF5bG9hZD0vKFswLTldKykoOihbMC05XSskfCl8KS9zO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5jb25zdCBkZWNvZGVCaWdJbnQ9KGVuY29kZWQpPT57XG5jb25zdCB0eXBlUHJlZml4PWVuY29kZWQuY2hhckF0KDApOy8qIGZhc3RlciB0aGFuIGVuY29kZWRbMF0qL1xudHlwZVByZWZpeD09PSdwJ3x8XG50eXBlUHJlZml4PT09J24nfHxcbkZhaWwgYEVuY29kZWQgYmlnaW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcblxuY29uc3R7XG5pbmRleDpsRGlnaXRzLFxuMTpzbkRpZ2l0cyxcbjI6dGFpbCxcbjM6ZGlnaXRzfT1cbmVuY29kZWQubWF0Y2gockJpZ0ludFBheWxvYWQpfHxGYWlsIGBEaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5cbnNuRGlnaXRzLmxlbmd0aD09PWxEaWdpdHN8fFxuRmFpbCBgVW5hcnktcHJlZml4ZWQgZGVjaW1hbCBkaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgbkRpZ2l0cz1wYXJzZUludChzbkRpZ2l0cywxMCk7XG5pZih0eXBlUHJlZml4PT09J24nKXtcbi8qIFRPRE8gQXNzZXJ0IHRvIHJlamVjdCBmb3JiaWRkZW4gZW5jb2RpbmdzKi9cbi8qIGxpa2UgXCJuMDpcIiBhbmQgXCJuMDA64oCmXCIgYW5kIFwibjkxOuKAplwiIHRocm91Z2ggXCJuOTk64oCmXCI/Ki9cbm5EaWdpdHM9MTAqKi8qKiBAdHlwZSB7bnVtYmVyfSAqL2xEaWdpdHMtbkRpZ2l0cztcbiB9XG5cbnRhaWwuY2hhckF0KDApPT09JzonfHxGYWlsIGBTZXBhcmF0b3IgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xuZGlnaXRzLmxlbmd0aD09PW5EaWdpdHN8fFxuRmFpbCBgRml4ZWQtbGVuZ3RoIGRpZ2l0IHNlcXVlbmNlIGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmxldCBuPUJpZ0ludChkaWdpdHMpO1xuaWYodHlwZVByZWZpeD09PSduJyl7XG4vKiBUT0RPIEFzc2VydCB0byByZWplY3QgZm9yYmlkZGVuIGVuY29kaW5ncyovXG4vKiBsaWtlIFwibjk6MFwiIGFuZCBcIm44OjAwXCIgYW5kIFwibjg6OTFcIiB0aHJvdWdoIFwibjg6OTlcIj8qL1xubj0tKDEwbioqQmlnSW50KG5EaWdpdHMpLW4pO1xuIH1cblxucmV0dXJuIG47XG4gfTtcblxuLyoqXG4gKiBBIHNwYXJzZSBhcnJheSBmb3Igd2hpY2ggZXZlcnkgcHJlc2VudCBpbmRleCBtYXBzIGEgY29kZSBwb2ludCBpbiB0aGUgQVNDSUlcbiAqIHJhbmdlIHRvIGEgY29ycmVzcG9uZGluZyBlc2NhcGUgc2VxdWVuY2UuXG4gKlxuICogRXNjYXBlcyBhbGwgY2hhcmFjdGVycyBmcm9tIFUrMDAwMCBOVUxMIHRvIFUrMDAxRiBJTkZPUk1BVElPTiBTRVBBUkFUT1IgT05FXG4gKiBsaWtlIGAhPGNoYXJhY3RlciBvZmZzZXQgYnkgMHgyMT5gIHRvIGF2b2lkIEpTT04uc3RyaW5naWZ5IGV4cGFuc2lvbiBhc1xuICogYFxcdUhISEhgLCBhbmQgc3BlY2lhbGx5IGVzY2FwZXMgVSswMDIwIFNQQUNFICh0aGUgYXJyYXkgZWxlbWVudCB0ZXJtaW5hdG9yKVxuICogYXMgYCFfYCBhbmQgVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgKHRoZSBlc2NhcGUgcHJlZml4KSBhcyBgIXxgIChib3RoIGNob3NlblxuICogZm9yIHZpc3VhbCBhcHByb3hpbWF0aW9uKS5cbiAqIFJlbGF0aXZlIGxleGljb2dyYXBoaWMgb3JkZXJpbmcgaXMgcHJlc2VydmVkIGJ5IHRoaXMgbWFwcGluZyBvZiBhbnkgY2hhcmFjdGVyXG4gKiBhdCBvciBiZWZvcmUgYCFgIGluIHRoZSBjb250aWd1b3VzIHJhbmdlIFsweDAwLi4weDIxXSB0byBhIHJlc3BlY3RpdmVcbiAqIGNoYXJhY3RlciBpbiBbMHgyMS4uMHg0MCwgMHg1RiwgMHg3Q10gcHJlY2VkZWQgYnkgYCFgICh3aGljaCBpcyBpdHNlbGYgaW4gdGhlXG4gKiByZXBsYWNlZCByYW5nZSkuXG4gKiBTaW1pbGFybHksIGVzY2FwZXMgYF5gIGFzIGBfQGAgYW5kIGBfYCBhcyBgX19gIGJlY2F1c2UgYF5gIGluZGljYXRlcyB0aGVcbiAqIHN0YXJ0IG9mIGFuIGVuY29kZWQgYXJyYXkuXG4gKlxuICogQHR5cGUge0FycmF5PHN0cmluZz59XG4gKi9cbmNvbnN0IHN0cmluZ0VzY2FwZXM9QXJyYXkoMHgyMikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8sY3ApPT57XG5zd2l0Y2goU3RyaW5nLmZyb21DaGFyQ29kZShjcCkpe1xuY2FzZScgJzpcbnJldHVybichXyc7XG5jYXNlJyEnOlxucmV0dXJuJyF8JztcbmRlZmF1bHQ6XG5yZXR1cm4gYCEke1N0cmluZy5mcm9tQ2hhckNvZGUoY3ArMHgyMSl9YDt9XG5cbiB9KTtcbnN0cmluZ0VzY2FwZXNbJ14nLmNoYXJDb2RlQXQoMCldPSdfQCc7XG5zdHJpbmdFc2NhcGVzWydfJy5jaGFyQ29kZUF0KDApXT0nX18nO1xuXG4vKipcbiAqIEVuY29kZXMgYSBzdHJpbmcgd2l0aCBlc2NhcGUgc2VxdWVuY2VzIGZvciB1c2UgaW4gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhzdHI6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVDb21wYWN0U3RyaW5nU3VmZml4PShzdHIpPT5cbnN0ci5yZXBsYWNlKC9bXFwwLSFeX10vZywoY2gpPT5zdHJpbmdFc2NhcGVzW2NoLmNoYXJDb2RlQXQoMCldKTtcblxuLyoqXG4gKiBEZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhlbmNvZGVkOiBzdHJpbmcpID0+IHN0cmluZ31cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeD0oZW5jb2RlZCk9PntcbnJldHVybiBlbmNvZGVkLnJlcGxhY2UoLyhbXFwwLSFfXSkoLnxcXG4pPy9nLChlc2MscHJlZml4LHN1ZmZpeCk9PntcbnN3aXRjaChlc2Mpe1xuY2FzZSchXyc6XG5yZXR1cm4nICc7XG5jYXNlJyF8JzpcbnJldHVybichJztcbmNhc2UnX0AnOlxucmV0dXJuJ14nO1xuY2FzZSdfXyc6XG5yZXR1cm4nXyc7XG5kZWZhdWx0OntcbmNvbnN0IGNoPS8qKiBAdHlwZSB7c3RyaW5nfSAqL3N1ZmZpeDtcbi8qIFRoZSByYW5nZSBvZiB2YWxpZCBgIWAtZXNjYXBlIHN1ZmZpeGVzIGlzIFsoMHgwMCsweDIxKS4uKDB4MUYrMHgyMSldLCBpLmUuKi9cbi8qIFsweDIxLi4weDQwXSAoVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgdG8gVSswMDQwIENPTU1FUkNJQUwgQVQpLiovXG5wcmVmaXg9PT0nIScmJnN1ZmZpeCE9PXVuZGVmaW5lZCYmY2g+PSchJyYmY2g8PSdAJ3x8XG5GYWlsIGBpbnZhbGlkIHN0cmluZyBlc2NhcGU6ICR7cShlc2MpfWA7XG5yZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZShjaC5jaGFyQ29kZUF0KDApLTB4MjEpO1xuIH19XG5cbiB9KTtcbiB9O1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1lbmNvZGVzIGEgc3RyaW5nIGZvciB1c2UgaW4gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IGVuY29kZUxlZ2FjeVN0cmluZ1N1ZmZpeD0oc3RyKT0+c3RyO1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1kZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBkZWNvZGVMZWdhY3lTdHJpbmdTdWZmaXg9KGVuY29kZWQpPT5lbmNvZGVkO1xuXG4vKipcbiAqIEVuY29kZXMgYW4gYXJyYXkgaW50byBhIHNlcXVlbmNlIG9mIGVuY29kZWQgZWxlbWVudHMgZm9yIHVzZSBpbiB0aGUgXCJjb21wYWN0T3JkZXJlZFwiXG4gKiBmb3JtYXQsIGVhY2ggdGVybWluYXRlZCBieSBhIHNwYWNlICh3aGljaCBpcyBwYXJ0IG9mIHRoZSBlc2NhcGVkIHJhbmdlIGluXG4gKiBcImNvbXBhY3RPcmRlcmVkXCIgZW5jb2RlZCBzdHJpbmdzKS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQ29tcGFjdEFycmF5PShhcnJheSxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IGNoYXJzPVsnXiddO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgYXJyYXkpe1xuY29uc3QgZW5jPWVuY29kZVBhc3NhYmxlKGVsZW1lbnQpO1xuY2hhcnMucHVzaChlbmMsJyAnKTtcbiB9XG5yZXR1cm4gY2hhcnMuam9pbignJyk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHBhcmFtIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX0gZGVjb2RlUGFzc2FibGVcbiAqIEBwYXJhbSB7bnVtYmVyfSBbc2tpcF1cbiAqIEByZXR1cm5zIHtBcnJheX1cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdEFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xubGV0IGRlcHRoPTA7XG4vKiBTY2FuIGVuY29kZWQgcmF0aGVyIHRoYW4gaXRzIHRhaWwgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmxldCBuZXh0SW5kZXg9c2tpcCsxO1xubGV0IGN1cnJlbnRFbGVtZW50U3RhcnQ9c2tpcCsxO1xuZm9yKGNvbnN0ezA6Y2gsaW5kZXg6aX1vZiBlbmNvZGVkLm1hdGNoQWxsKC9bXFxeIF0vZykpe1xuY29uc3QgaW5kZXg9LyoqIEB0eXBlIHtudW1iZXJ9ICovaTtcbmlmKGluZGV4PD1za2lwKXtcbmlmKGluZGV4PT09c2tpcCl7XG5jaD09PSdeJ3x8RmFpbCBgRW5jb2RlZCBhcnJheSBleHBlY3RlZDogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuIH1cbiB9ZWxzZSBpZihjaD09PSdeJyl7XG4vKiBUaGlzIGlzIHRoZSBzdGFydCBvZiBhIG5lc3RlZCBhcnJheS4qL1xuLyogVE9ETzogU2luY2UgdGhlIHN5bnRheCBvZiBuZXN0ZWQgYXJyYXlzIG11c3QgYmUgdmFsaWRhdGVkIGFzIHBhcnQgb2YqL1xuLyogZGVjb2RpbmcgdGhlIG91dGVyIG9uZSwgY29uc2lkZXIgZGVjb2RpbmcgdGhlbSBoZXJlIGludG8gYSBzaGFyZWQgY2FjaGUqL1xuLyogcmF0aGVyIHRoYW4gZGlzY2FyZGluZyBpbmZvcm1hdGlvbiBhYm91dCB0aGVpciBjb250ZW50cyB1bnRpbCB0aGUgbGF0ZXIqL1xuLyogZGVjb2RlUGFzc2FibGUuKi9cbmRlcHRoKz0xO1xuIH1lbHNle1xuLyogVGhpcyBpcyBhIHRlcm1pbmF0ZWQgZWxlbWVudC4qL1xuaWYoaW5kZXg9PT1uZXh0SW5kZXgpe1xuLyogQSB0ZXJtaW5hdG9yIGFmdGVyIGBbYCBvciBhbiBhbm90aGVyIHRlcm1pbmF0b3IgaW5kaWNhdGVzIHRoYXQgYW4gYXJyYXkgaXMgZG9uZS4qL1xuZGVwdGgtPTE7XG5kZXB0aD49MHx8XG4vKiBwcmV0dGllci1pZ25vcmUqL1xuRmFpbCBgdW5leHBlY3RlZCBhcnJheSBlbGVtZW50IHRlcm1pbmF0b3I6ICR7ZW5jb2RlZC5zbGljZShza2lwLGluZGV4KzIpfWA7XG4gfVxuaWYoZGVwdGg9PT0wKXtcbi8qIFdlIGhhdmUgYSBjb21wbGV0ZSBlbGVtZW50IG9mIHRoZSB0b3Btb3N0IGFycmF5LiovXG5lbGVtZW50cy5wdXNoKFxuZGVjb2RlUGFzc2FibGUoZW5jb2RlZC5zbGljZShjdXJyZW50RWxlbWVudFN0YXJ0LGluZGV4KSkpO1xuXG5jdXJyZW50RWxlbWVudFN0YXJ0PWluZGV4KzE7XG4gfVxuIH1cbi8qIEFkdmFuY2UgdGhlIGluZGV4LiovXG5uZXh0SW5kZXg9aW5kZXgrMTtcbiB9XG5kZXB0aD09PTB8fEZhaWwgYHVudGVybWluYXRlZCBhcnJheTogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xubmV4dEluZGV4PT09ZW5jb2RlZC5sZW5ndGh8fFxuRmFpbCBgdW50ZXJtaW5hdGVkIGFycmF5IGVsZW1lbnQ6ICR7Z2V0U3VmZml4KFxuZW5jb2RlZCxcbmN1cnJlbnRFbGVtZW50U3RhcnQpXG4gfWA7XG5yZXR1cm4gaGFyZGVuKGVsZW1lbnRzKTtcbiB9O1xuXG4vKipcbiAqIFBlcmZvcm1zIHRoZSBvcmlnaW5hbCBhcnJheSBlbmNvZGluZywgd2hpY2ggZXNjYXBlcyBhbGwgZW5jb2RlZCBhcnJheVxuICogZWxlbWVudHMgcmF0aGVyIHRoYW4ganVzdCBzdHJpbmdzIChgXFx1MDAwMGAgYXMgdGhlIGVsZW1lbnQgdGVybWluYXRvciBhbmRcbiAqIGBcXHUwMDAxYCBhcyB0aGUgZXNjYXBlIHByZWZpeCBmb3IgYFxcdTAwMDBgIG9yIGBcXHUwMDAxYCkuXG4gKiBUaGlzIG5lY2Vzc2l0YXRlZCBhbiB1bmRlc2lyYWJsZSBhbW91bnQgb2YgaXRlcmF0aW9uIGFuZCBleHBhbnNpb247IHNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI2MCNkaXNjdXNzaW9uX3I5NjAzNjk4MjZcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlTGVnYWN5QXJyYXk9KGFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgY2hhcnM9WydbJ107XG5mb3IoY29uc3QgZWxlbWVudCBvZiBhcnJheSl7XG5jb25zdCBlbmM9ZW5jb2RlUGFzc2FibGUoZWxlbWVudCk7XG5mb3IoY29uc3QgYyBvZiBlbmMpe1xuaWYoYz09PSdcXHUwMDAwJ3x8Yz09PSdcXHUwMDAxJyl7XG5jaGFycy5wdXNoKCdcXHUwMDAxJyk7XG4gfVxuY2hhcnMucHVzaChjKTtcbiB9XG5jaGFycy5wdXNoKCdcXHUwMDAwJyk7XG4gfVxucmV0dXJuIGNoYXJzLmpvaW4oJycpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gUGFzc2FibGV9IGRlY29kZVBhc3NhYmxlXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7QXJyYXl9XG4gKi9cbmNvbnN0IGRlY29kZUxlZ2FjeUFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xuY29uc3QgZWxlbUNoYXJzPVtdO1xuLyogVXNlIGEgc3RyaW5nIGl0ZXJhdG9yIHRvIGF2b2lkIHNsb3cgaW5kZXhlZCBhY2Nlc3MgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5sZXQgc3RpbGxUb1NraXA9c2tpcCsxO1xubGV0IGluRXNjYXBlPWZhbHNlO1xuZm9yKGNvbnN0IGMgb2YgZW5jb2RlZCl7XG5pZihzdGlsbFRvU2tpcD4wKXtcbnN0aWxsVG9Ta2lwLT0xO1xuaWYoc3RpbGxUb1NraXA9PT0wKXtcbmM9PT0nWyd8fEZhaWwgYEVuY29kZWQgYXJyYXkgZXhwZWN0ZWQ6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbiB9XG4gfWVsc2UgaWYoaW5Fc2NhcGUpe1xuYz09PSdcXHUwMDAwJ3x8XG5jPT09J1xcdTAwMDEnfHxcbkZhaWwgYFVuZXhwZWN0ZWQgY2hhcmFjdGVyIGFmdGVyIHUwMDAxIGVzY2FwZTogJHtjfWA7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDAnKXtcbmNvbnN0IGVuY29kZWRFbGVtZW50PWVsZW1DaGFycy5qb2luKCcnKTtcbmVsZW1DaGFycy5sZW5ndGg9MDtcbmNvbnN0IGVsZW1lbnQ9ZGVjb2RlUGFzc2FibGUoZW5jb2RlZEVsZW1lbnQpO1xuZWxlbWVudHMucHVzaChlbGVtZW50KTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDEnKXtcbmluRXNjYXBlPXRydWU7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tY29udGludWUqL1xuY29udGludWU7XG4gfWVsc2V7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9XG5pbkVzY2FwZT1mYWxzZTtcbiB9XG4haW5Fc2NhcGV8fEZhaWwgYHVuZXhwZWN0ZWQgZW5kIG9mIGVuY29kaW5nICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmVsZW1DaGFycy5sZW5ndGg9PT0wfHxcbkZhaWwgYGVuY29kaW5nIHRlcm1pbmF0ZWQgZWFybHk6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbnJldHVybiBoYXJkZW4oZWxlbWVudHMpO1xuIH07XG5cbmNvbnN0IGVuY29kZVJlY29yZD0ocmVjb3JkLGVuY29kZUFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgbmFtZXM9cmVjb3JkTmFtZXMocmVjb3JkKTtcbmNvbnN0IHZhbHVlcz1yZWNvcmRWYWx1ZXMocmVjb3JkLG5hbWVzKTtcbnJldHVybiBgKCR7ZW5jb2RlQXJyYXkoaGFyZGVuKFtuYW1lcyx2YWx1ZXNdKSxlbmNvZGVQYXNzYWJsZSl9YDtcbiB9O1xuXG5jb25zdCBkZWNvZGVSZWNvcmQ9KGVuY29kZWQsZGVjb2RlQXJyYXksZGVjb2RlUGFzc2FibGUsc2tpcD0wKT0+e1xuYXNzZXJ0KGVuY29kZWQuY2hhckF0KHNraXApPT09JygnKTtcbi8qIFNraXAgdGhlIFwiKFwiIGluc2lkZSBgZGVjb2RlQXJyYXlgIHRvIGF2b2lkIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5jb25zdCB1bnppcHBlZEVudHJpZXM9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudW56aXBwZWRFbnRyaWVzLmxlbmd0aD09PTJ8fFxuRmFpbCBgZXhwZWN0ZWQga2V5cyx2YWx1ZXMgcGFpcjogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuY29uc3Rba2V5cyx2YWxzXT11bnppcHBlZEVudHJpZXM7XG5cbnBhc3NTdHlsZU9mKGtleXMpPT09J2NvcHlBcnJheScmJlxucGFzc1N0eWxlT2YodmFscyk9PT0nY29weUFycmF5JyYmXG5rZXlzLmxlbmd0aD09PXZhbHMubGVuZ3RoJiZcbmtleXMuZXZlcnkoKGtleSk9PnR5cGVvZiBrZXk9PT0nc3RyaW5nJyl8fFxuRmFpbCBgbm90IGEgdmFsaWQgcmVjb3JkIGVuY29kaW5nOiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG5jb25zdCBtYXBFbnRyaWVzPWtleXMubWFwKChrZXksaSk9PltrZXksdmFsc1tpXV0pO1xuY29uc3QgcmVjb3JkPWhhcmRlbihmcm9tRW50cmllcyhtYXBFbnRyaWVzKSk7XG5hc3NlcnRSZWNvcmQocmVjb3JkLCdkZWNvZGVkIHJlY29yZCcpO1xucmV0dXJuIHJlY29yZDtcbiB9O1xuXG5jb25zdCBlbmNvZGVUYWdnZWQ9KHRhZ2dlZCxlbmNvZGVBcnJheSxlbmNvZGVQYXNzYWJsZSk9PlxuIGA6JHtlbmNvZGVBcnJheShoYXJkZW4oW2dldFRhZyh0YWdnZWQpLHRhZ2dlZC5wYXlsb2FkXSksZW5jb2RlUGFzc2FibGUpfWA7XG5cbmNvbnN0IGRlY29kZVRhZ2dlZD0oZW5jb2RlZCxkZWNvZGVBcnJheSxkZWNvZGVQYXNzYWJsZSxza2lwPTApPT57XG5hc3NlcnQoZW5jb2RlZC5jaGFyQXQoc2tpcCk9PT0nOicpO1xuLyogU2tpcCB0aGUgXCI6XCIgaW5zaWRlIGBkZWNvZGVBcnJheWAgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmNvbnN0IHRhZ2dlZFBheWxvYWQ9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudGFnZ2VkUGF5bG9hZC5sZW5ndGg9PT0yfHxcbkZhaWwgYGV4cGVjdGVkIHRhZyxwYXlsb2FkIHBhaXI6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmNvbnN0W3RhZyxwYXlsb2FkXT10YWdnZWRQYXlsb2FkO1xucGFzc1N0eWxlT2YodGFnKT09PSdzdHJpbmcnfHxcbkZhaWwgYG5vdCBhIHZhbGlkIHRhZ2dlZCBlbmNvZGluZzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLHBheWxvYWQpO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVSZW1vdGFibGU9KHVuc2FmZUVuY29kZVJlbW90YWJsZSx2ZXJpZnlFbmNvZGluZyk9PntcbmNvbnN0IGVuY29kZVJlbW90YWJsZT0ocixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVJlbW90YWJsZShyLGlubmVyRW5jb2RlKTtcbnR5cGVvZiBlbmNvZGluZz09PSdzdHJpbmcnJiZlbmNvZGluZy5jaGFyQXQoMCk9PT0ncid8fFxuRmFpbCBgUmVtb3RhYmxlIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcInJcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ1JlbW90YWJsZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUmVtb3RhYmxlO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVQcm9taXNlPSh1bnNhZmVFbmNvZGVQcm9taXNlLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlUHJvbWlzZT0ocCxpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVByb21pc2UocCxpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09Jz8nfHxcbkZhaWwgYFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiP1wiOiAke2VuY29kaW5nfWA7XG52ZXJpZnlFbmNvZGluZyhlbmNvZGluZywnUHJvbWlzZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUHJvbWlzZTtcbiB9O1xuXG5jb25zdCBtYWtlRW5jb2RlRXJyb3I9KHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlRXJyb3I9KGVycixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZUVycm9yKGVycixpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09JyEnfHxcbkZhaWwgYEVycm9yIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcIiFcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ0Vycm9yJyk7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfTtcbnJldHVybiBlbmNvZGVFcnJvcjtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVSZW1vdGFibGVdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVQcm9taXNlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVFcnJvcl1cbiAqIEBwcm9wZXJ0eSB7J2xlZ2FjeU9yZGVyZWQnIHwgJ2NvbXBhY3RPcmRlcmVkJ30gW2Zvcm1hdF1cbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9IGVuY29kZVN0cmluZ1N1ZmZpeFxuICogQHBhcmFtIHsoYXJyOiB1bmtub3duW10sIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZykgPT4gc3RyaW5nfSBlbmNvZGVBcnJheVxuICogQHBhcmFtIHtSZXF1aXJlZDxFbmNvZGVPcHRpb25zPiAmIHt2ZXJpZnlFbmNvZGluZz86IChlbmNvZGVkOiBzdHJpbmcsIGxhYmVsOiBzdHJpbmcpID0+IHZvaWR9fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KHA6IFBhc3NhYmxlKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckVuY29kZT0oZW5jb2RlU3RyaW5nU3VmZml4LGVuY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZTp1bnNhZmVFbmNvZGVSZW1vdGFibGUsXG5lbmNvZGVQcm9taXNlOnVuc2FmZUVuY29kZVByb21pc2UsXG5lbmNvZGVFcnJvcjp1bnNhZmVFbmNvZGVFcnJvcixcbnZlcmlmeUVuY29kaW5nPSgpPT57IH19PVxub3B0aW9ucztcbmNvbnN0IGVuY29kZVJlbW90YWJsZT1tYWtlRW5jb2RlUmVtb3RhYmxlKFxudW5zYWZlRW5jb2RlUmVtb3RhYmxlLFxudmVyaWZ5RW5jb2RpbmcpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlPW1ha2VFbmNvZGVQcm9taXNlKHVuc2FmZUVuY29kZVByb21pc2UsdmVyaWZ5RW5jb2RpbmcpO1xuY29uc3QgZW5jb2RlRXJyb3I9bWFrZUVuY29kZUVycm9yKHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKTtcblxuY29uc3QgaW5uZXJFbmNvZGU9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gZW5jb2RlRXJyb3IocGFzc2FibGUsaW5uZXJFbmNvZGUpO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXNzYWJsZSk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnbnVsbCc6e1xucmV0dXJuJ3YnO1xuIH1cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm4neic7XG4gfVxuY2FzZSdudW1iZXInOntcbnJldHVybiBlbmNvZGVCaW5hcnk2NChwYXNzYWJsZSk7XG4gfVxuY2FzZSdzdHJpbmcnOntcbnJldHVybiBgcyR7ZW5jb2RlU3RyaW5nU3VmZml4KHBhc3NhYmxlKX1gO1xuIH1cbmNhc2UnYm9vbGVhbic6e1xucmV0dXJuIGBiJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gZW5jb2RlQmlnSW50KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xucmV0dXJuIGVuY29kZVJlbW90YWJsZShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIGVuY29kZUVycm9yKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBlbmNvZGVQcm9taXNlKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuLyogU3RyaW5ncyBhbmQgc3ltYm9scyBzaGFyZSBlbmNvZGluZyBsb2dpYy4qL1xuY29uc3QgbmFtZT1uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbnJldHVybiBgeSR7ZW5jb2RlU3RyaW5nU3VmZml4KG5hbWUpfWA7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbnJldHVybiBlbmNvZGVBcnJheShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG5yZXR1cm4gZW5jb2RlUmVjb3JkKHBhc3NhYmxlLGVuY29kZUFycmF5LGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJuIGVuY29kZVRhZ2dlZChwYXNzYWJsZSxlbmNvZGVBcnJheSxpbm5lckVuY29kZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBhICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgdXNlZCBhcyBhIGNvbGxlY3Rpb24gcGFzc2FibGVgO1xuIH19XG5cbiB9O1xucmV0dXJuIGlubmVyRW5jb2RlO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yXVxuICovXG5cbmNvbnN0IGxpYmVyYWxEZWNvZGVycz0vKiogQHR5cGUge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSAqL1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL3tcbmRlY29kZVJlbW90YWJsZTooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZCxcbmRlY29kZVByb21pc2U6KF9lbmNvZGluZyxfaW5uZXJEZWNvZGUpPT51bmRlZmluZWQsXG5kZWNvZGVFcnJvcjooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZH07XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfSBkZWNvZGVTdHJpbmdTdWZmaXhcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZywgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlLCBza2lwPzogbnVtYmVyKSA9PiB1bmtub3duW119IGRlY29kZUFycmF5XG4gKiBAcGFyYW0ge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckRlY29kZT0oZGVjb2RlU3RyaW5nU3VmZml4LGRlY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVSZW1vdGFibGUsZGVjb2RlUHJvbWlzZSxkZWNvZGVFcnJvcn09b3B0aW9ucztcbi8qKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9ICovXG5jb25zdCBpbm5lckRlY29kZT0oZW5jb2RlZCxza2lwPTApPT57XG5zd2l0Y2goZW5jb2RlZC5jaGFyQXQoc2tpcCkpe1xuY2FzZSd2Jzp7XG5yZXR1cm4gbnVsbDtcbiB9XG5jYXNlJ3onOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdmJzp7XG5yZXR1cm4gZGVjb2RlQmluYXJ5NjQoZW5jb2RlZCxza2lwKTtcbiB9XG5jYXNlJ3MnOntcbnJldHVybiBkZWNvZGVTdHJpbmdTdWZmaXgoZ2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKSk7XG4gfVxuY2FzZSdiJzp7XG5jb25zdCBzdWJzdHJpbmc9Z2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKTtcbmlmKHN1YnN0cmluZz09PSd0cnVlJyl7XG5yZXR1cm4gdHJ1ZTtcbiB9ZWxzZSBpZihzdWJzdHJpbmc9PT0nZmFsc2UnKXtcbnJldHVybiBmYWxzZTtcbiB9XG50aHJvdyBGYWlsIGBleHBlY3RlZCBlbmNvZGVkIGJvb2xlYW4gdG8gYmUgXCJidHJ1ZVwiIG9yIFwiYmZhbHNlXCI6ICR7c3Vic3RyaW5nfWA7XG4gfVxuY2FzZSduJzpcbmNhc2UncCc6e1xucmV0dXJuIGRlY29kZUJpZ0ludChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSk7XG4gfVxuY2FzZSdyJzp7XG5yZXR1cm4gZGVjb2RlUmVtb3RhYmxlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJz8nOntcbnJldHVybiBkZWNvZGVQcm9taXNlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJyEnOntcbnJldHVybiBkZWNvZGVFcnJvcihnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSxpbm5lckRlY29kZSk7XG4gfVxuY2FzZSd5Jzp7XG4vKiBTdHJpbmdzIGFuZCBzeW1ib2xzIHNoYXJlIGRlY29kaW5nIGxvZ2ljLiovXG5jb25zdCBuYW1lPWRlY29kZVN0cmluZ1N1ZmZpeChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKzEpKTtcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG4gfVxuY2FzZSdbJzpcbmNhc2UnXic6e1xuLyogQHRzLWV4cGVjdC1lcnJvciBUeXBlICd1bmtub3duW10nIGlzIG5vdCBQYXNzYWJsZSovXG5yZXR1cm4gZGVjb2RlQXJyYXkoZW5jb2RlZCxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJygnOntcbnJldHVybiBkZWNvZGVSZWNvcmQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJzonOntcbnJldHVybiBkZWNvZGVUYWdnZWQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYGludmFsaWQgZGF0YWJhc2Uga2V5OiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaW5uZXJEZWNvZGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXNzYWJsZUtpdFxuICogQHByb3BlcnR5IHtSZXR1cm5UeXBlPG1ha2VJbm5lckVuY29kZT59IGVuY29kZVBhc3NhYmxlXG4gKiBAcHJvcGVydHkge1JldHVyblR5cGU8bWFrZUlubmVyRGVjb2RlPn0gZGVjb2RlUGFzc2FibGVcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlT3B0aW9ucyAmIERlY29kZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhc3NhYmxlS2l0PShvcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGU9KHIsXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3J9YCxcbmVuY29kZVByb21pc2U9KHAsXyk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwfWAsXG5lbmNvZGVFcnJvcj0oZXJyLF8pPT5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke2Vycn1gLFxuZm9ybWF0PSdsZWdhY3lPcmRlcmVkJyxcblxuZGVjb2RlUmVtb3RhYmxlPShlbmNvZGluZyxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZVByb21pc2U9KGVuY29kaW5nLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZUVycm9yPShlbmNvZGluZyxfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gfT1cbm9wdGlvbnM7XG5cbi8qKiBAdHlwZSB7UGFzc2FibGVLaXRbJ2VuY29kZVBhc3NhYmxlJ119ICovXG5sZXQgZW5jb2RlUGFzc2FibGU7XG5jb25zdCBlbmNvZGVPcHRpb25zPXtlbmNvZGVSZW1vdGFibGUsZW5jb2RlUHJvbWlzZSxlbmNvZGVFcnJvcixmb3JtYXR9O1xuaWYoZm9ybWF0PT09J2NvbXBhY3RPcmRlcmVkJyl7XG5jb25zdCBsaWJlcmFsRGVjb2RlPW1ha2VJbm5lckRlY29kZShcbmRlY29kZUNvbXBhY3RTdHJpbmdTdWZmaXgsXG5kZWNvZGVDb21wYWN0QXJyYXksXG5saWJlcmFsRGVjb2RlcnMpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGluZ1xuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgdmVyaWZ5RW5jb2Rpbmc9KGVuY29kaW5nLGxhYmVsKT0+e1xuIWVuY29kaW5nLm1hdGNoKHJDMCl8fFxuRmFpbCBgJHtiKFxubGFiZWwpXG4gfSBlbmNvZGluZyBtdXN0IG5vdCBjb250YWluIGEgQzAgY29udHJvbCBjaGFyYWN0ZXI6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRlY29kZWQ9ZGVjb2RlQ29tcGFjdEFycmF5KCBgXnYgJHtlbmNvZGluZ30gdiBgLGxpYmVyYWxEZWNvZGUpO1xuaXNBcnJheShkZWNvZGVkKSYmXG5kZWNvZGVkLmxlbmd0aD09PTMmJlxuZGVjb2RlZFswXT09PW51bGwmJlxuZGVjb2RlZFsyXT09PW51bGx8fFxuRmFpbCBgJHtiKGxhYmVsKX0gZW5jb2RpbmcgbXVzdCBiZSBlbWJlZGRhYmxlOiAke2VuY29kaW5nfWA7XG4gfTtcbmNvbnN0IGVuY29kZUNvbXBhY3Q9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmVuY29kZUNvbXBhY3RBcnJheSxcbnsuLi5lbmNvZGVPcHRpb25zLHZlcmlmeUVuY29kaW5nfSk7XG5cbmVuY29kZVBhc3NhYmxlPShwYXNzYWJsZSk9PiBgfiR7ZW5jb2RlQ29tcGFjdChwYXNzYWJsZSl9YDtcbiB9ZWxzZSBpZihmb3JtYXQ9PT0nbGVnYWN5T3JkZXJlZCcpe1xuZW5jb2RlUGFzc2FibGU9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZW5jb2RlTGVnYWN5QXJyYXksXG5lbmNvZGVPcHRpb25zKTtcblxuIH1lbHNle1xudGhyb3cgRmFpbCBgVW5yZWNvZ25pemVkIGZvcm1hdDogJHtxKGZvcm1hdCl9YDtcbiB9XG5cbmNvbnN0IGRlY29kZU9wdGlvbnM9e2RlY29kZVJlbW90YWJsZSxkZWNvZGVQcm9taXNlLGRlY29kZUVycm9yfTtcbmNvbnN0IGRlY29kZUNvbXBhY3Q9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmRlY29kZUNvbXBhY3RBcnJheSxcbmRlY29kZU9wdGlvbnMpO1xuXG5jb25zdCBkZWNvZGVMZWdhY3k9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZGVjb2RlTGVnYWN5QXJyYXksXG5kZWNvZGVPcHRpb25zKTtcblxuY29uc3QgZGVjb2RlUGFzc2FibGU9KGVuY29kZWQpPT57XG4vKiBBIGxlYWRpbmcgXCJ+XCIgaW5kaWNhdGVzIHRoZSB2MiBlbmNvZGluZyAod2l0aCBlc2NhcGluZyBpbiBzdHJpbmdzIHJhdGhlciB0aGFuIGFycmF5cykuKi9cbi8qIFNraXAgaXQgaW5zaWRlIGBkZWNvZGVDb21wYWN0YCB0byBhdm9pZCBzbG93IGBzdWJzdHJpbmdgIGluIFhTLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODQqL1xuaWYoZW5jb2RlZC5jaGFyQXQoMCk9PT0nficpe1xucmV0dXJuIGRlY29kZUNvbXBhY3QoZW5jb2RlZCwxKTtcbiB9XG5yZXR1cm4gZGVjb2RlTGVnYWN5KGVuY29kZWQpO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe2VuY29kZVBhc3NhYmxlLGRlY29kZVBhc3NhYmxlfSk7XG4gfTskaM2PX29uY2UubWFrZVBhc3NhYmxlS2l0KG1ha2VQYXNzYWJsZUtpdCk7XG5oYXJkZW4obWFrZVBhc3NhYmxlS2l0KTtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0WydlbmNvZGVQYXNzYWJsZSddfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVBhc3NhYmxlPShlbmNvZGVPcHRpb25zKT0+e1xuY29uc3R7ZW5jb2RlUGFzc2FibGV9PW1ha2VQYXNzYWJsZUtpdChlbmNvZGVPcHRpb25zKTtcbnJldHVybiBlbmNvZGVQYXNzYWJsZTtcbiB9OyRozY9fb25jZS5tYWtlRW5jb2RlUGFzc2FibGUobWFrZUVuY29kZVBhc3NhYmxlKTtcbmhhcmRlbihtYWtlRW5jb2RlUGFzc2FibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7RGVjb2RlT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7UGFzc2FibGVLaXRbJ2RlY29kZVBhc3NhYmxlJ119XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlUGFzc2FibGU9KGRlY29kZU9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVQYXNzYWJsZX09bWFrZVBhc3NhYmxlS2l0KGRlY29kZU9wdGlvbnMpO1xucmV0dXJuIGRlY29kZVBhc3NhYmxlO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVQYXNzYWJsZShtYWtlRGVjb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5cbmNvbnN0ICAgICAgICBpc0VuY29kZWRSZW1vdGFibGU9KGVuY29kZWQpPT5lbmNvZGVkLmNoYXJBdCgwKT09PSdyJzskaM2PX29uY2UuaXNFbmNvZGVkUmVtb3RhYmxlKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5oYXJkZW4oaXNFbmNvZGVkUmVtb3RhYmxlKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlIHtSZWNvcmQ8UGFzc1N0eWxlLCBzdHJpbmc+fVxuICogVGhlIHNpbmdsZSBwcmVmaXggY2hhcmFjdGVycyB0byBiZSB1c2VkIGZvciBlYWNoIFBhc3NTdHlsZSBjYXRlZ29yeS5cbiAqIGBiaWdpbnRgIGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBlYWNoIG9mIHRob3NlIGNoYXJhY3RlcnNcbiAqIGluZGl2aWR1YWxseSBpcyBhIHZhbGlkIGJpZ2ludCBwcmVmaXggKGBuYCBmb3IgXCJuZWdhdGl2ZVwiIGFuZCBgcGAgZm9yXG4gKiBcInBvc2l0aXZlXCIpLCBhbmQgY29weUFycmF5IGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBvbmUgZW5jb2RpbmdcbiAqIHByZWZpeGVzIGFycmF5cyB3aXRoIGBbYCB3aGlsZSB0aGUgb3RoZXIgdXNlcyBgXmAgKHdoaWNoIGlzIHByb2hpYml0ZWQgZnJvbVxuICogYXBwZWFyaW5nIGluIGFuIGVuY29kZWQgc3RyaW5nKS5cbiAqIFRoZSBvcmRlcmluZyBvZiB0aGVzZSBwcmVmaXhlcyBpcyB0aGUgc2FtZSBhcyB0aGUgcmFua09yZGVyaW5nIG9mIHRoZWlyXG4gKiByZXNwZWN0aXZlIFBhc3NTdHlsZXMsIGFuZCByYW5rT3JkZXIuanMgaW1wb3J0cyB0aGUgdGFibGUgZm9yIHRoaXMgcHVycG9zZS5cbiAqXG4gKiBJbiBhZGRpdGlvbiwgYHxgIGlzIHRoZSByZW1vdGFibGUtPm9yZGluYWwgbWFwcGluZyBwcmVmaXg6XG4gKiBUaGlzIGlzIG5vdCB1c2VkIGluIGNvdmVycyBidXQgaXQgaXNcbiAqIHJlc2VydmVkIGZyb20gdGhlIHNhbWUgc2V0IG9mIHN0cmluZ3MuIE5vdGUgdGhhdCB0aGUgcHJlZml4IGlzID4gYW55XG4gKiBwcmVmaXggdXNlZCBieSBhbnkgY292ZXIgc28gdGhhdCBvcmRpbmFsIG1hcHBpbmcga2V5cyBhcmUgYWx3YXlzIG91dHNpZGVcbiAqIHRoZSByYW5nZSBvZiB2YWxpZCBjb2xsZWN0aW9uIGVudHJ5IGtleXMuXG4gKi9cbmNvbnN0ICAgICAgICBwYXNzU3R5bGVQcmVmaXhlcz17XG5lcnJvcjonIScsXG5jb3B5UmVjb3JkOicoJyxcbnRhZ2dlZDonOicsXG5wcm9taXNlOic/JyxcbmNvcHlBcnJheTonW14nLFxuYm9vbGVhbjonYicsXG5udW1iZXI6J2YnLFxuYmlnaW50OiducCcsXG5yZW1vdGFibGU6J3InLFxuc3RyaW5nOidzJyxcbm51bGw6J3YnLFxuc3ltYm9sOid5Jyxcbi8qIEJlY2F1c2UgQXJyYXkucHJvdG90eXBlLnNvcnQgcHV0cyB1bmRlZmluZWQgdmFsdWVzIGF0IHRoZSBlbmQgd2l0aG91dCovXG4vKiBwYXNzaW5nIHRoZW0gdG8gYSBjb21wYXJpc29uIGZ1bmN0aW9uLCB1bmRlZmluZWQgTVVTVCBiZSB0aGUgbGFzdCovXG4vKiBjYXRlZ29yeS4qL1xudW5kZWZpbmVkOid6J307JGjNj19vbmNlLnBhc3NTdHlsZVByZWZpeGVzKHBhc3NTdHlsZVByZWZpeGVzKTtcblxuT2JqZWN0LnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVByZWZpeGVzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVByZWZpeGVzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlY29yZE5hbWVzIjpbInJlY29yZE5hbWVzIl0sInJlY29yZFZhbHVlcyI6WyJyZWNvcmRWYWx1ZXMiXSwiemVyb1BhZCI6WyJ6ZXJvUGFkIl0sIm1ha2VQYXNzYWJsZUtpdCI6WyJtYWtlUGFzc2FibGVLaXQiXSwibWFrZUVuY29kZVBhc3NhYmxlIjpbIm1ha2VFbmNvZGVQYXNzYWJsZSJdLCJtYWtlRGVjb2RlUGFzc2FibGUiOlsibWFrZURlY29kZVBhc3NhYmxlIl0sImlzRW5jb2RlZFJlbW90YWJsZSI6WyJpc0VuY29kZWRSZW1vdGFibGUiXSwicGFzc1N0eWxlUHJlZml4ZXMiOlsicGFzc1N0eWxlUHJlZml4ZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAMYqu5Eo6AABKOgAAKwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb0NhcERhdGEuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIlFDTEFTUyIsIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSIsIm1ha2VFbmNvZGVUb0NhcERhdGEiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxpc09iamVjdCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLFgsRmFpbCxxOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRozY9fYSA9PiAoaXNFcnJvckxpa2UgPSAkaM2PX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjNj19hID0+IChtYWtlVGFnZ2VkID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImdldFRhZ1wiLCBbJGjNj19hID0+IChnZXRUYWcgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaM2PX2EgPT4gKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzYWJsZSwgUmVtb3RhYmxlT2JqZWN0fSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuLyoqIEBpbXBvcnQge0VuY29kaW5nLCBFbmNvZGluZ1VuaW9ufSBmcm9tICcuL3R5cGVzLmpzJyAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsXG5kZWZpbmVQcm9wZXJ0aWVzLFxuaXMsXG5lbnRyaWVzLFxuZnJvbUVudHJpZXMsXG5mcmVlemV9PVxuT2JqZWN0O1xuXG4vKipcbiAqIFNwZWNpYWwgcHJvcGVydHkgbmFtZSB0aGF0IGluZGljYXRlcyBhbiBlbmNvZGluZyB0aGF0IG5lZWRzIHNwZWNpYWxcbiAqIGRlY29kaW5nLlxuICovXG5jb25zdCBRQ0xBU1M9J0BxY2xhc3MnOyRozY9fb25jZS5RQ0xBU1MoUUNMQVNTKTtcblxuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEByZXR1cm5zIHtlbmNvZGVkIGlzIEVuY29kaW5nVW5pb259XG4gKi9cbmNvbnN0IGhhc1FDbGFzcz0oZW5jb2RlZCk9Pmhhc093blByb3BlcnR5T2YoZW5jb2RlZCxRQ0xBU1MpO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7c3RyaW5nfSBxY2xhc3NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBxY2xhc3NNYXRjaGVzPShlbmNvZGVkLHFjbGFzcyk9PlxuaXNPYmplY3QoZW5jb2RlZCkmJlxuIWlzQXJyYXkoZW5jb2RlZCkmJlxuaGFzUUNsYXNzKGVuY29kZWQpJiZcbmVuY29kZWRbUUNMQVNTXT09PXFjbGFzcztcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVUb0NhcERhdGFPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGVPYmplY3QsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlRXJyb3JUb0NhcERhdGFdXG4gKi9cblxuY29uc3QgZG9udEVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT0ocmVtKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9tKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YDtcblxuY29uc3QgZG9udEVuY29kZUVycm9yVG9DYXBEYXRhPShlcnIpPT5GYWlsIGBlcnJvciBvYmplY3QgdW5leHBlY3RlZDogJHtlcnJ9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZVRvQ2FwRGF0YU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IEVuY29kaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVRvQ2FwRGF0YT0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhPWRvbnRFbmNvZGVSZW1vdGFibGVUb0NhcERhdGEsXG5lbmNvZGVQcm9taXNlVG9DYXBEYXRhPWRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhLFxuZW5jb2RlRXJyb3JUb0NhcERhdGE9ZG9udEVuY29kZUVycm9yVG9DYXBEYXRhfT1cbmVuY29kZU9wdGlvbnM7XG5cbi8qKlxuICogTXVzdCBlbmNvZGUgYHZhbGAgaW50byBwbGFpbiBKU09OIGRhdGEgKmNhbm9uaWNhbGx5Kiwgc3VjaCB0aGF0XG4gKiBgSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSkgPT09IEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpYC4gRm9yIG1vc3RcbiAqIGVuY29kaW5ncywgdGhlIG9yZGVyIG9mIHByb3BlcnRpZXMgb2YgZWFjaCBub2RlIG9mIHRoZSBvdXRwdXRcbiAqIHN0cnVjdHVyZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhbGdvcml0aG0gYmVsb3cgd2l0aG91dCBzcGVjaWFsXG4gKiBhcnJhbmdlbWVudCwgdXN1YWxseSBieSBiZWluZyBleHByZXNzZWQgZGlyZWN0bHkgYXMgYW4gb2JqZWN0IGxpdGVyYWwuXG4gKiBUaGUgZXhjZXB0aW9uIGlzIGNvcHlSZWNvcmRzLCB3aG9zZSBuYXR1cmFsIGVudW1lcmF0aW9uIG9yZGVyXG4gKiBjYW4gZGlmZmVyIGJldHdlZW4gY29weVJlY29yZHMgdGhhdCBvdXIgZGlzdHJpYnV0ZWQgb2JqZWN0IHNlbWFudGljc1xuICogY29uc2lkZXJzIHRvIGJlIGVxdWl2YWxlbnQuXG4gKiBTaW5jZSwgZm9yIGVhY2ggY29weVJlY29yZCwgd2Ugb25seSBhY2NlcHQgc3RyaW5nIHByb3BlcnR5IG5hbWVzLFxuICogbm90IHN5bWJvbHMsIHdlIGNhbiBjYW5vbmljYWxseSBzb3J0IHRoZSBuYW1lcyBmaXJzdC5cbiAqIEpTT04uc3RyaW5naWZ5IHdpbGwgdGhlbiB2aXNpdCB0aGVzZSBpbiB0aGF0IHNvcnRlZCBvcmRlci5cbiAqXG4gKiBFbmNvZGluZyB3aXRoIGEgY2Fub25pY2FsLUpTT04gZW5jb2RlciB3b3VsZCBhbHNvIHNvbHZlIHRoaXMgY2Fub25pY2FsbmVzc1xuICogcHJvYmxlbSBpbiBhIG1vcmUgbW9kdWxhciBhbmQgZW5jYXBzdWxhdGVkIG1hbm5lci4gTm90ZSB0aGF0IHRoZVxuICogYWN0dWFsIG9yZGVyIHByb2R1Y2VkIGhlcmUsIHRob3VnaCBpdCBhZ3JlZXMgd2l0aCBjYW5vbmljYWwtSlNPTiBvblxuICogY29weVJlY29yZCBwcm9wZXJ0eSBvcmRlcmluZywgZGlmZmVycyBmcm9tIGNhbm9uaWNhbC1KU09OIGFzIGEgd2hvbGVcbiAqIGluIHRoYXQgdGhlIG90aGVyIHJlY29yZCBwcm9wZXJ0aWVzIGFyZSB2aXNpdGVkIGluIHRoZSBvcmRlciBpbiB3aGljaFxuICogdGhleSBhcmUgbGl0ZXJhbGx5IHdyaXR0ZW4gYmVsb3cuIFRPRE8gcGVyaGFwcyB3ZSBzaG91bGQgaW5kZWVkIHN3aXRjaFxuICogdG8gYSBjYW5vbmljYWwgSlNPTiBlbmNvZGVyLCBhbmQgbm90IGRlbGljYXRlbHkgZGVwZW5kIG9uIHRoZSBvcmRlclxuICogaW4gd2hpY2ggdGhlc2Ugb2JqZWN0IGxpdGVyYWxzIGFyZSB3cml0dGVuLlxuICpcbiAqIFJlYWRlcnMgbXVzdCBub3QgY2FyZSBhYm91dCB0aGlzIG9yZGVyIGFueXdheS4gV2UgaW1wb3NlIHRoaXMgcmVxdWlyZW1lbnRcbiAqIG1haW5seSB0byByZWR1Y2Ugbm9uLWRldGVybWluaXNtIGV4cG9zZWQgb3V0c2lkZSBhIHZhdC5cbiAqXG4gKiBAcGFyYW0ge2FueX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHtFbmNvZGluZ30gZXhjZXB0IHRoYXQgYGVuY29kZVRvQ2FwRGF0YWAgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb0NhcERhdGFgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb0NhcERhdGFSZWN1cj0ocGFzc2FibGUpPT57XG4vKiBGaXJzdCB3ZSBoYW5kbGUgYWxsIHByaW1pdGl2ZXMuIFNvbWUgY2FuIGJlIHJlcHJlc2VudGVkIGRpcmVjdGx5IGFzKi9cbi8qIEpTT04sIGFuZCBzb21lIG11c3QgYmUgZW5jb2RlZCBhcyBbUUNMQVNTXSBjb21wb3NpdGVzLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybntbUUNMQVNTXTondW5kZWZpbmVkJ307XG4gfVxuY2FzZSdudW1iZXInOntcbi8qIFNwZWNpYWwtY2FzZSBudW1iZXJzIHdpdGggbm8gZGlnaXQtYmFzZWQgcmVwcmVzZW50YXRpb24uKi9cbmlmKE51bWJlci5pc05hTihwYXNzYWJsZSkpe1xucmV0dXJue1tRQ0xBU1NdOidOYU4nfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybntbUUNMQVNTXTonSW5maW5pdHknfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106Jy1JbmZpbml0eSd9O1xuIH1cbi8qIFBhc3MgdGhyb3VnaCBldmVyeXRoaW5nIGVsc2UsIHJlcGxhY2luZyAtMCB3aXRoIDAuKi9cbnJldHVybiBpcyhwYXNzYWJsZSwtMCk/MDpwYXNzYWJsZTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJue1xuW1FDTEFTU106J2JpZ2ludCcsXG5kaWdpdHM6U3RyaW5nKHBhc3NhYmxlKX07XG5cbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJue1xuW1FDTEFTU106J3N5bWJvbCcsXG5uYW1lfTtcblxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaGFzT3duUHJvcGVydHlPZihwYXNzYWJsZSxRQ0xBU1MpKXtcbi8qIEhpbGJlcnQgaG90ZWwqL1xuY29uc3R7W1FDTEFTU106cWNsYXNzVmFsdWUsLi4ucmVzdH09cGFzc2FibGU7XG4vKiogQHR5cGUge0VuY29kaW5nfSAqL1xuY29uc3QgcmVzdWx0PXtcbltRQ0xBU1NdOidoaWxiZXJ0Jyxcbm9yaWdpbmFsOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHFjbGFzc1ZhbHVlKX07XG5cbmlmKG93bktleXMocmVzdCkubGVuZ3RoPj0xKXtcbi8qIFdlIGhhcmRlbiB0aGUgZW50aXJlIGNhcERhdGEgZW5jb2RpbmcgYmVmb3JlIHdlIHJldHVybiBpdC4qL1xuLyogYGVuY29kZVRvQ2FwRGF0YWAgcmVxdWlyZXMgdGhhdCBpdHMgaW5wdXQgYmUgUGFzc2FibGUsIGFuZCovXG4vKiB0aGVyZWZvcmUgaGFyZGVuZWQuKi9cbi8qIFRoZSBgZnJlZXplYCBoZXJlIGlzIG5lZWRlZCBhbnl3YXksIGJlY2F1c2UgdGhlIGByZXN0YCBpcyovXG4vKiBmcmVzaGx5IGNvbnN0cnVjdGVkIGJ5IHRoZSBgLi4uYCBhYm92ZSwgYW5kIHdlJ3JlIHVzaW5nIGl0Ki9cbi8qIGFzIGltcHV0IGluIGFub3RoZXIgY2FsbCB0byBgZW5jb2RlVG9DYXBEYXRhYC4qL1xucmVzdWx0LnJlc3Q9ZW5jb2RlVG9DYXBEYXRhUmVjdXIoZnJlZXplKHJlc3QpKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEN1cnJlbnRseSBjb3B5UmVjb3JkIGFsbG93cyBvbmx5IHN0cmluZyBrZXlzIHNvIHRoaXMgd2lsbCovXG4vKiB3b3JrLiBJZiB3ZSBhbGxvdyBzb3J0YWJsZSBzeW1ib2wga2V5cywgdGhpcyB3aWxsIG5lZWQgdG8qL1xuLyogYmVjb21lIG1vcmUgaW50ZXJlc3RpbmcuKi9cbmNvbnN0IG5hbWVzPW93bktleXMocGFzc2FibGUpLnNvcnQoKTtcbnJldHVybiBmcm9tRW50cmllcyhcbm5hbWVzLm1hcCgobmFtZSk9PltuYW1lLGVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlW25hbWVdKV0pKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuW1FDTEFTU106J3RhZ2dlZCcsXG50YWc6Z2V0VGFnKHBhc3NhYmxlKSxcbnBheWxvYWQ6ZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhKFxucGFzc2FibGUsXG5lbmNvZGVUb0NhcERhdGFSZWN1cik7XG5cbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MpXG4gfSAke3EoJ3Nsb3QnKX06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgZW5jb2RlZD1lbmNvZGVQcm9taXNlVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTLFxuJ3Nsb3QnKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlRXJyb3JUb0NhcERhdGEocGFzc2FibGUsZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuaWYocWNsYXNzTWF0Y2hlcyhlbmNvZGVkLCdlcnJvcicpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidlcnJvcicpXG4gfTogJHtlbmNvZGVkfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYGludGVybmFsOiBVbnJlY29nbml6ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5jb25zdCBlbmNvZGVUb0NhcERhdGE9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gaGFyZGVuKGVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKSk7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZSkpO1xuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvQ2FwRGF0YShtYWtlRW5jb2RlVG9DYXBEYXRhKTtcbmhhcmRlbihtYWtlRW5jb2RlVG9DYXBEYXRhKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVQcm9taXNlRnJvbUNhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gRXJyb3J9IFtkZWNvZGVFcnJvckZyb21DYXBEYXRhXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0oc2xvdEVuY29kaW5nKT0+XG5GYWlsIGByZW1vdGFibGUgb3IgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Nsb3RFbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbUNhcERhdGE9KGVycm9yRW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyb3JFbmNvZGluZ31gO1xuXG4vKipcbiAqIFRoZSBjdXJyZW50IGVuY29kaW5nIGRvZXMgbm90IGdpdmUgdGhlIGRlY29kZXIgZW5vdWdoIGludG8gdG8gZGlzdGluZ3Vpc2hcbiAqIHdoZXRoZXIgYSBzbG90IHJlcHJlc2VudHMgYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLiBBcyBhbiBpbXBsZW1lbnRhdGlvblxuICogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmVcbiAqIHByb3ZpZGVkIGFuZCB0aGV5IG11c3QgYmUgdGhlIHNhbWUuXG4gKlxuICogVGhpcyBzZWVtcyBsaWtlIHRoZSBiZXN0IHN0YXJ0aW5nIHBvaW50IHRvIGluY3JlbWVudGFsbHkgZXZvbHZlIHRvIGFuXG4gKiBBUEkgd2hlcmUgdGhlc2UgY2FuIHJlbGlhYmx5IGRpZmZlci5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzRcbiAqXG4gKiBAcGFyYW0ge0RlY29kZU9wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBFbmNvZGluZykgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlRnJvbUNhcERhdGE9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPWRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YSxcbmRlY29kZVByb21pc2VGcm9tQ2FwRGF0YT1kb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVFcnJvckZyb21DYXBEYXRhPWRvbnREZWNvZGVFcnJvckZyb21DYXBEYXRhfT1cbmRlY29kZU9wdGlvbnM7XG5cbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPT09ZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhfHxcbkZhaWwgYEFuIGltcGxlbWVudGF0aW9uIHJlc3RyaWN0aW9uIGZvciBub3c6IElmIGVpdGhlciBkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSBvciBkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZSBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lOiAke3EoXG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSlcbiB9IHZzICR7cShkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEpfWA7XG5cbi8qKlxuICogYGRlY29kZUZyb21DYXBEYXRhYCBtYXkgcmVseSBvbiBganNvbkVuY29kZWRgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBqc29uRW5jb2RlZGBcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvQ2FwRGF0YWBcbiAqIGFib3ZlLCBpLmUuLCBgZGVjb2RlRnJvbUNhcERhdGFgIGNhbm5vdCByZWx5IG9uIGBqc29uRW5jb2RlZGAgYmVpbmcgYVxuICogdmFsaWQgbWFyc2hhbGxlZCByZXByZXNlbnRhdGlvbi4gUmF0aGVyLCBgZGVjb2RlRnJvbUNhcERhdGFgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30ganNvbkVuY29kZWQgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tQ2FwRGF0YT0oanNvbkVuY29kZWQpPT57XG5pZighaXNPYmplY3QoanNvbkVuY29kZWQpKXtcbi8qIHByaW1pdGl2ZXMgcGFzcyB0aHJvdWdoKi9cbnJldHVybiBqc29uRW5jb2RlZDtcbiB9XG5pZihpc0FycmF5KGpzb25FbmNvZGVkKSl7XG5yZXR1cm4ganNvbkVuY29kZWQubWFwKChlbmNvZGVkVmFsKT0+ZGVjb2RlRnJvbUNhcERhdGEoZW5jb2RlZFZhbCkpO1xuIH1lbHNlIGlmKGhhc1FDbGFzcyhqc29uRW5jb2RlZCkpe1xuY29uc3QgcWNsYXNzPWpzb25FbmNvZGVkW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCAke3EoUUNMQVNTKX0gdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuc3dpdGNoKHFjbGFzcyl7XG4vKiBFbmNvZGluZyBvZiBwcmltaXRpdmVzIG5vdCBoYW5kbGVkIGJ5IEpTT04qL1xuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdOYU4nOntcbnJldHVybiBOYU47XG4gfVxuY2FzZSdJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnLUluZmluaXR5Jzp7XG5yZXR1cm4tSW5maW5pdHk7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309anNvbkVuY29kZWQ7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuIEJpZ0ludChkaWdpdHMpO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBEZXByZWNhdGVkIHFjbGFzcy4gVE9ETyBtYWtlIGNvbmRpdGlvbmFsKi9cbi8qIG9uIGVudmlyb25tZW50IHZhcmlhYmxlLiBFdmVudHVhbGx5IHJlbW92ZSwgYnV0IGFmdGVyIGNvbmZpZGVudCovXG4vKiB0aGF0IHRoZXJlIGFyZSBubyBtb3JlIHN1cHBvcnRlZCBzZW5kZXJzLiovXG4vKiovXG5yZXR1cm4gU3ltYm9sLmFzeW5jSXRlcmF0b3I7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PWpzb25FbmNvZGVkO1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PWpzb25FbmNvZGVkO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLGRlY29kZUZyb21DYXBEYXRhKHBheWxvYWQpKTtcbiB9XG5jYXNlJ3Nsb3QnOntcbi8qIFNlZSBub3RlIGFib3ZlIGFib3V0IGhvdyB0aGUgY3VycmVudCBlbmNvZGluZyBjYW5ub3QgcmVsaWFibHkqL1xuLyogZGlzdGluZ3Vpc2ggd2hpY2ggd2Ugc2hvdWxkIGNhbGwsIHNvIGluIHRoZSBub24tZGVmYXVsdCBjYXNlKi9cbi8qIGJvdGggbXVzdCBiZSB0aGUgc2FtZSBhbmQgaXQgZG9lc24ndCBtYXR0ZXIgd2hpY2ggd2UgY2FsbC4qL1xuY29uc3QgZGVjb2RlZD1kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YShcbmpzb25FbmNvZGVkLFxuZGVjb2RlRnJvbUNhcERhdGEpO1xuXG4vKiBCRVdBUkU6IGNhcGRhdGEgZG9lcyBub3QgY2hlY2sgdGhhdCBgZGVjb2RlZGAgaXMqL1xuLyogYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLCBzaW5jZSB0aGF0IHdvdWxkIGJyZWFrIHNvbWUqL1xuLyogY2FwZGF0YSBjbGllbnRzLiBXZSBhcmUgZGVwcmVjYXRpbmcgY2FwZGF0YSwgYW5kIHRoZXNlIGNsaWVudHMqL1xuLyogd2lsbCBuZWVkIHRvIHVwZGF0ZSBiZWZvcmUgc3dpdGNoaW5nIHRvIHNtYWxsY2Fwcy4qL1xucmV0dXJuIGRlY29kZWQ7XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZGVjb2RlZD1kZWNvZGVFcnJvckZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbmlmKHBhc3NTdHlsZU9mKGRlY29kZWQpPT09J2Vycm9yJyl7XG5yZXR1cm4gZGVjb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YSBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7ZGVjb2RlZH1gO1xuIH1cbmNhc2UnaGlsYmVydCc6e1xuY29uc3R7b3JpZ2luYWwscmVzdH09anNvbkVuY29kZWQ7XG5oYXNPd25Qcm9wZXJ0eU9mKGpzb25FbmNvZGVkLCdvcmlnaW5hbCcpfHxcbkZhaWwgYEludmFsaWQgSGlsYmVydCBIb3RlbCBlbmNvZGluZyAke2pzb25FbmNvZGVkfWA7XG4vKiBEb24ndCBoYXJkZW4gc2luY2Ugd2UncmUgbm90IGRvbmUgbXV0YXRpbmcgaXQqL1xuY29uc3QgcmVzdWx0PXtbUUNMQVNTXTpkZWNvZGVGcm9tQ2FwRGF0YShvcmlnaW5hbCl9O1xuaWYoaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwncmVzdCcpKXtcbmNvbnN0IGlzTm9uRW1wdHlPYmplY3Q9XG50eXBlb2YgcmVzdD09PSdvYmplY3QnJiZcbnJlc3QhPT1udWxsJiZcbm93bktleXMocmVzdCkubGVuZ3RoPj0xO1xuaWYoIWlzTm9uRW1wdHlPYmplY3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyBtdXN0IGJlIGEgbm9uLWVtcHR5IG9iamVjdDogJHtyZXN0fWA7XG4gfVxuY29uc3QgcmVzdE9iaj1kZWNvZGVGcm9tQ2FwRGF0YShyZXN0KTtcbi8qIFRPRE8gcmVhbGx5IHNob3VsZCBhc3NlcnQgdGhhdCBgcGFzc1N0eWxlT2YocmVzdClgIGlzKi9cbi8qIGAnY29weVJlY29yZCdgIGJ1dCB3ZSdkIGhhdmUgdG8gaGFyZGVuIGl0IGFuZCBpdCBpcyB0b28qL1xuLyogZWFybHkgdG8gZG8gdGhhdC4qL1xuIWhhc093blByb3BlcnR5T2YocmVzdE9iaixRQ0xBU1MpfHxcbkZhaWwgYFJlc3QgbXVzdCBub3QgY29udGFpbiBpdHMgb3duIGRlZmluaXRpb24gb2YgJHtxKFFDTEFTUyl9YDtcbmRlZmluZVByb3BlcnRpZXMocmVzdWx0LGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocmVzdE9iaikpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBUaGlzIGlzIHRoZSBlcnJvciBjYXNlIHdlJ3JlIHRlc3RpbmcgZm9yKi9cbmNhc2UnaWJpZCc6e1xudGhyb3cgRmFpbCBgVGhlIGNhcERhdGEgcHJvdG9jb2wgbm8gbG9uZ2VyIHN1cHBvcnRzICR7cShRQ0xBU1MpfSAke3EoXG5xY2xhc3MpXG4gfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2V7XG5hc3NlcnQodHlwZW9mIGpzb25FbmNvZGVkPT09J29iamVjdCcmJmpzb25FbmNvZGVkIT09bnVsbCk7XG5jb25zdCBkZWNvZGVFbnRyeT0oW25hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5ICR7cShuYW1lKX0gb2YgJHtqc29uRW5jb2RlZH0gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoanNvbkVuY29kZWQpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVGcm9tQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZURlY29kZUZyb21DYXBEYXRhKG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJRQ0xBU1MiOlsiUUNMQVNTIl0sIm1ha2VFbmNvZGVUb0NhcERhdGEiOlsibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJtYWtlRGVjb2RlRnJvbUNhcERhdGEiOlsibWFrZURlY29kZUZyb21DYXBEYXRhIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIiwibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IHBhc3NTdHlsZU9mLGlzRXJyb3JMaWtlLG1ha2VUYWdnZWQsZ2V0VGFnLGhhc093blByb3BlcnR5T2YsYXNzZXJ0UGFzc2FibGVTeW1ib2wsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZSxYLEZhaWwscTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRozY9fYSA9PiAobWFrZVRhZ2dlZCA9ICRozY9fYSldXSxbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV0sW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc2FibGUsIFJlbW90YWJsZX0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZScgKi9cbi8qIEZJWE1FIGRlZmluZSBhY3R1YWwgdHlwZXMqL1xuLyoqIEB0eXBlZGVmIHthbnl9IFNtYWxsY2Fwc0VuY29kaW5nICovXG4vKiogQHR5cGVkZWYge2FueX0gU21hbGxjYXBzRW5jb2RpbmdVbmlvbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtpcyxlbnRyaWVzLGZyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0IEJBTkc9JyEnLmNoYXJDb2RlQXQoMCk7XG5jb25zdCBEQVNIPSctJy5jaGFyQ29kZUF0KDApO1xuXG4vKipcbiAqIEFuIGBlbmNvZGVUb1NtYWxsY2Fwc2AgZnVuY3Rpb24gdGFrZXMgYSBwYXNzYWJsZSBhbmQgcmV0dXJucyBhXG4gKiBKU09OLXJlcHJlc2VudGFibGUgb2JqZWN0IChpLmUuLCByb3VuZC10cmlwcGluZyBpdCB0aHJvdWdoXG4gKiBgSlNPTi5zdHJpbmdpZnlgIGFuZCBgSlNPTi5wYXJzZWAgd2l0aCBubyByZXBsYWNlcnMgb3IgcmV2aXZlcnNcbiAqIHJldHVybnMgYW4gZXF1aXZhbGVudCBzdHJ1Y3R1cmUgZXhjZXB0IGZvciBvYmplY3QgaWRlbnRpdHkpLlxuICogV2UgY2FsbCB0aGlzIHJlcHJlc2VudGF0aW9uIGEgU21hbGxjYXBzIEVuY29kaW5nLlxuICpcbiAqIEEgYGRlY29kZUZyb21TbWFsbGNhcHNgIGZ1bmN0aW9uIHRha2VzIGFzIGFyZ3VtZW50IHdoYXQgaXRcbiAqICphc3N1bWVzKiBpcyB0aGUgcmVzdWx0IG9mIGEgcGxhaW4gYEpTT04ucGFyc2VgIHdpdGggbm8gcmVzb2x2ZXIuIEl0IHRoZW5cbiAqIG11c3QgdmFsaWRhdGUgdGhhdCBpdCBpcyBhIHZhbGlkIFNtYWxsY2FwcyBFbmNvZGluZywgYW5kIGlmIGl0IGlzLFxuICogcmV0dXJuIGEgY29ycmVzcG9uZGluZyBwYXNzYWJsZS5cbiAqXG4gKiBTbWFsbGNhcHMgY29uc2lkZXJzIHRoZSBjaGFyYWN0ZXJzIGJldHdlZW4gYCFgIChhc2NpaSBjb2RlIDMzLCBCQU5HKVxuICogYW5kIGAtYCAoYXNjaWkgY29kZSA0NSwgREFTSCkgdG8gYmUgc3BlY2lhbCBwcmVmaXhlcyBhbGxvd2luZ1xuICogcmVwcmVzZW50YXRpb24gb2YgSlNPTi1pbmNvbXBhdGlibGUgZGF0YSB1c2luZyBzdHJpbmdzLlxuICogVGhlc2UgY2hhcmFjdGVycywgaW4gb3JkZXIsIGFyZSBgIVwiIyQlJicoKSorLC1gXG4gKiBPZiB0aGVzZSwgc21hbGxjYXBzIGN1cnJlbnRseSB1c2VzIHRoZSBmb2xsb3dpbmc6XG4gKlxuICogICogYCFgIC0gZXNjYXBlZCBzdHJpbmdcbiAqICAqIGArYCAtIG5vbi1uZWdhdGl2ZSBiaWdpbnRcbiAqICAqIGAtYCAtIG5lZ2F0aXZlIGJpZ2ludFxuICogICogYCNgIC0gbWFuaWZlc3QgY29uc3RhbnRcbiAqICAqIGAlYCAtIHN5bWJvbFxuICogICogYCRgIC0gcmVtb3RhYmxlXG4gKiAgKiBgJmAgLSBwcm9taXNlXG4gKlxuICogQWxsIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycyAoYFwiJygpKixgKSBhcmUgcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuXG4gKlxuICogVGhlIG1hbmlmZXN0IGNvbnN0YW50cyB0aGF0IHNtYWxsY2FwcyBjdXJyZW50bHkgdXNlcyBmb3IgdmFsdWVzOlxuICogICogYCN1bmRlZmluZWRgXG4gKiAgKiBgI05hTmBcbiAqICAqIGAjSW5maW5pdHlgXG4gKiAgKiBgIy1JbmZpbml0eWBcbiAqXG4gKiBhbmQgZm9yIHByb3BlcnR5IG5hbWVzIGFuYWxvZ291cyB0byBjYXBkYXRhIEBxY2xhc3M6XG4gKiAgKiBgI3RhZ2BcbiAqICAqIGAjZXJyb3JgXG4gKlxuICogQWxsIG90aGVyIGVuY29kZWQgc3RyaW5ncyBiZWdpbm5pbmcgd2l0aCBgI2AgYXJlIHJlc2VydmVkIGZvclxuICogZnV0dXJlIHVzZS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFN0clxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHN0YXJ0c1NwZWNpYWw9KGVuY29kZWRTdHIpPT57XG5pZihlbmNvZGVkU3RyPT09Jycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbi8qIGNoYXJDb2RlQXQoMCkgYW5kIG51bWJlciBjb21wYXJlIGlzIGEgYml0IGZhc3Rlci4qL1xuY29uc3QgY29kZT1lbmNvZGVkU3RyLmNoYXJDb2RlQXQoMCk7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgeW9kYSovXG5yZXR1cm4gQkFORzw9Y29kZSYmY29kZTw9REFTSDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZVRvU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIHJlbW90YWJsZTogUmVtb3RhYmxlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVFcnJvclRvU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz0ocmVtKT0+XG5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtyZW19YDtcblxuY29uc3QgZG9udEVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz0ocHJvbSk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwcm9tfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIpPT5cbkZhaWwgYGVycm9yIG9iamVjdCB1bmV4cGVjdGVkOiAke3EoZXJyKX1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlVG9TbWFsbGNhcHNPcHRpb25zfSBbZW5jb2RlT3B0aW9uc11cbiAqIGVuY29kZU9wdGlvbnMgaXMgYWN0dWFsbHkgb3B0aW9uYWwsIGJ1dCBub3QgbWFya2VkIGFzIHN1Y2ggdG8gd29yayBhcm91bmRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAyODZcbiAqXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW5jb2RlVG9TbWFsbGNhcHM9KGVuY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzPWRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyxcbmVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz1kb250RW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzLFxuZW5jb2RlRXJyb3JUb1NtYWxsY2Fwcz1kb250RW5jb2RlRXJyb3JUb1NtYWxsY2Fwc309XG5lbmNvZGVPcHRpb25zO1xuXG5jb25zdCBhc3NlcnRFbmNvZGVkRXJyb3I9KGVuY29kaW5nKT0+e1xudHlwZW9mIGVuY29kaW5nPT09J29iamVjdCcmJmhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyNlcnJvcicpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGhhdmUgXCIjZXJyb3JcIiBwcm9wZXJ0eTogJHtxKFxuZW5jb2RpbmcpXG4gfWA7XG4vKiBBc3NlcnQgdGhhdCB0aGUgI2Vycm9yIHByb3BlcnR5IGRlY29kZXMgdG8gYSBzdHJpbmcuKi9cbmNvbnN0IG1lc3NhZ2U9ZW5jb2RpbmdbJyNlcnJvciddO1xudHlwZW9mIG1lc3NhZ2U9PT0nc3RyaW5nJyYmKFxuIXN0YXJ0c1NwZWNpYWwobWVzc2FnZSl8fG1lc3NhZ2UuY2hhckF0KDApPT09JyEnKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBoYXZlIHN0cmluZyBtZXNzYWdlOiAke3EobWVzc2FnZSl9YDtcbiB9O1xuXG4vKipcbiAqIE11c3QgZW5jb2RlIGB2YWxgIGludG8gcGxhaW4gSlNPTiBkYXRhICpjYW5vbmljYWxseSosIHN1Y2ggdGhhdFxuICogYEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpID09PSBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKWAuIEZvciBtb3N0XG4gKiBlbmNvZGluZ3MsIHRoZSBvcmRlciBvZiBwcm9wZXJ0aWVzIG9mIGVhY2ggbm9kZSBvZiB0aGUgb3V0cHV0XG4gKiBzdHJ1Y3R1cmUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYWxnb3JpdGhtIGJlbG93IHdpdGhvdXQgc3BlY2lhbFxuICogYXJyYW5nZW1lbnQsIHVzdWFsbHkgYnkgYmVpbmcgZXhwcmVzc2VkIGRpcmVjdGx5IGFzIGFuIG9iamVjdCBsaXRlcmFsLlxuICogVGhlIGV4Y2VwdGlvbiBpcyBjb3B5UmVjb3Jkcywgd2hvc2UgbmF0dXJhbCBlbnVtZXJhdGlvbiBvcmRlclxuICogY2FuIGRpZmZlciBiZXR3ZWVuIGNvcHlSZWNvcmRzIHRoYXQgb3VyIGRpc3RyaWJ1dGVkIG9iamVjdCBzZW1hbnRpY3NcbiAqIGNvbnNpZGVycyB0byBiZSBlcXVpdmFsZW50LlxuICogU2luY2UsIGZvciBlYWNoIGNvcHlSZWNvcmQsIHdlIG9ubHkgYWNjZXB0IHN0cmluZyBwcm9wZXJ0eSBuYW1lcyxcbiAqIG5vdCBzeW1ib2xzLCB3ZSBjYW4gY2Fub25pY2FsbHkgc29ydCB0aGUgbmFtZXMgZmlyc3QuXG4gKiBKU09OLnN0cmluZ2lmeSB3aWxsIHRoZW4gdmlzaXQgdGhlc2UgaW4gdGhhdCBzb3J0ZWQgb3JkZXIuXG4gKlxuICogRW5jb2Rpbmcgd2l0aCBhIGNhbm9uaWNhbC1KU09OIGVuY29kZXIgd291bGQgYWxzbyBzb2x2ZSB0aGlzIGNhbm9uaWNhbG5lc3NcbiAqIHByb2JsZW0gaW4gYSBtb3JlIG1vZHVsYXIgYW5kIGVuY2Fwc3VsYXRlZCBtYW5uZXIuIE5vdGUgdGhhdCB0aGVcbiAqIGFjdHVhbCBvcmRlciBwcm9kdWNlZCBoZXJlLCB0aG91Z2ggaXQgYWdyZWVzIHdpdGggY2Fub25pY2FsLUpTT04gb25cbiAqIGNvcHlSZWNvcmQgcHJvcGVydHkgb3JkZXJpbmcsIGRpZmZlcnMgZnJvbSBjYW5vbmljYWwtSlNPTiBhcyBhIHdob2xlXG4gKiBpbiB0aGF0IHRoZSBvdGhlciByZWNvcmQgcHJvcGVydGllcyBhcmUgdmlzaXRlZCBpbiB0aGUgb3JkZXIgaW4gd2hpY2hcbiAqIHRoZXkgYXJlIGxpdGVyYWxseSB3cml0dGVuIGJlbG93LiBUT0RPIHBlcmhhcHMgd2Ugc2hvdWxkIGluZGVlZCBzd2l0Y2hcbiAqIHRvIGEgY2Fub25pY2FsIEpTT04gZW5jb2RlciwgYW5kIG5vdCBkZWxpY2F0ZWx5IGRlcGVuZCBvbiB0aGUgb3JkZXJcbiAqIGluIHdoaWNoIHRoZXNlIG9iamVjdCBsaXRlcmFscyBhcmUgd3JpdHRlbi5cbiAqXG4gKiBSZWFkZXJzIG11c3Qgbm90IGNhcmUgYWJvdXQgdGhpcyBvcmRlciBhbnl3YXkuIFdlIGltcG9zZSB0aGlzIHJlcXVpcmVtZW50XG4gKiBtYWlubHkgdG8gcmVkdWNlIG5vbi1kZXRlcm1pbmlzbSBleHBvc2VkIG91dHNpZGUgYSB2YXQuXG4gKlxuICogQHBhcmFtIHthbnl9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7U21hbGxjYXBzRW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb1NtYWxsY2Fwc2AgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb1NtYWxsY2Fwc2AgaXMgbm90XG4gKiBkaXJlY3RseSBleHBvc2VkLlxuICogV2hhdCdzIGV4cG9zZWQgaW5zdGVhZCBpcyBhIHdyYXBwZXIgdGhhdCBmcmVlemVzIHRoZSBvdXRwdXQgYmVmb3JlXG4gKiByZXR1cm5pbmcuIElmIHRoaXMgdHVybnMgb3V0IHRvIGltcGVkZSBzdGF0aWMgYW5hbHlzaXMgZm9yIGBoYXJkZW5gIHNhZmV0eSxcbiAqIHdlIGNhbiBhbHdheXMgcHV0IHRoZSAobm93IHJlZHVuZGFudCkgaGFyZGVucyBiYWNrIGluLiBUaGV5IGRvbid0IGh1cnQuXG4gKi9cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgaW50byBzbWFsbGNhcHMgc3RyaW5ncy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZihzdGFydHNTcGVjaWFsKHBhc3NhYmxlKSl7XG4vKiBTdHJpbmdzIHRoYXQgc3RhcnQgd2l0aCBhIHNwZWNpYWwgY2hhciBhcmUgcXVvdGVkIHdpdGggYCFgLiovXG4vKiBTaW5jZSBgIWAgaXMgaXRzZWxmIGEgc3BlY2lhbCBjaGFyYWN0ZXIsIHRoaXMgdHJpdmlhbGx5IGRvZXMqL1xuLyogdGhlIEhpbGJlcnQgaG90ZWwuIEFsc28sIHNpbmNlIHRoZSBzcGVjaWFsIGNoYXJhY3RlcnMgYXJlKi9cbi8qIGEgY29udGludW91cyBzdWJyYW5nZSBvZiBhc2NpaSwgdGhpcyBxdW90aW5nIGlzIHNvcnQtb3JkZXIqL1xuLyogcHJlc2VydmluZy4qL1xucmV0dXJuIGAhJHtwYXNzYWJsZX1gO1xuIH1cbi8qIEFsbCBvdGhlciBzdHJpbmdzIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJyN1bmRlZmluZWQnO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybicjTmFOJztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybicjSW5maW5pdHknO1xuIH1lbHNlIGlmKHBhc3NhYmxlPT09LUluZmluaXR5KXtcbnJldHVybicjLUluZmluaXR5JztcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0IHN0cj1TdHJpbmcocGFzc2FibGUpO1xucmV0dXJuICgvKiogQHR5cGUge2JpZ2ludH0gKi9wYXNzYWJsZTwwbj9zdHI6YCske3N0cn1gKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJuIGAlJHtuYW1lfWA7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKG5hbWUpLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm57XG4nI3RhZyc6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihnZXRUYWcocGFzc2FibGUpKSxcbnBheWxvYWQ6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZS5wYXlsb2FkKX07XG5cbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyQnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuLyogYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEJ1dCBsaW50ZXIgY29uZnVzZWQqL1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIkXCI6ICR7cmVzdWx0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyYnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJlwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvclRvU21hbGxjYXBzKHBhc3NhYmxlLGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuYXNzZXJ0RW5jb2RlZEVycm9yKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9TbWFsbGNhcHM9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5jb25zdCByZXN1bHQ9aGFyZGVuKFxuZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKSk7XG5cbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwcyk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvU21hbGxjYXBzKG1ha2VFbmNvZGVUb1NtYWxsY2Fwcyk7XG5oYXJkZW4obWFrZUVuY29kZVRvU21hbGxjYXBzKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVGcm9tU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBSZW1vdGFibGV9IFtkZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRFcnJvcjogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7cShlbmNvZGluZyl9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0RlY29kZUZyb21TbWFsbGNhcHNPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogU21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZUZyb21TbWFsbGNhcHM9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9ZG9udERlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9ZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwc309XG5kZWNvZGVPcHRpb25zO1xuXG4vKipcbiAqIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBtYXkgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBlbmNvZGluZ2BcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvU21hbGxjYXBzYFxuICogYWJvdmUsIGkuZS4sIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBjYW5ub3QgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIGFcbiAqIHZhbGlkIG1hcnNoYWxsZWQgcmVwcmVzZW50YXRpb24uIFJhdGhlciwgYGRlY29kZUZyb21TbWFsbGNhcHNgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtTbWFsbGNhcHNFbmNvZGluZ30gZW5jb2RpbmcgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PntcbnN3aXRjaCh0eXBlb2YgZW5jb2Rpbmcpe1xuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzp7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY2FzZSdzdHJpbmcnOntcbmlmKCFzdGFydHNTcGVjaWFsKGVuY29kaW5nKSl7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY29uc3QgYz1lbmNvZGluZy5jaGFyQXQoMCk7XG5zd2l0Y2goYyl7XG5jYXNlJyEnOntcbi8qIHVuLWhpbGJlcnQtaWZ5IHRoZSBzdHJpbmcqL1xucmV0dXJuIGVuY29kaW5nLnNsaWNlKDEpO1xuIH1cbmNhc2UnJSc6e1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShlbmNvZGluZy5zbGljZSgxKSk7XG4gfVxuY2FzZScjJzp7XG5zd2l0Y2goZW5jb2Rpbmcpe1xuY2FzZScjdW5kZWZpbmVkJzp7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNhc2UnI05hTic6e1xucmV0dXJuIE5hTjtcbiB9XG5jYXNlJyNJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnIy1JbmZpbml0eSc6e1xucmV0dXJuLUluZmluaXR5O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGB1bmtub3duIGNvbnN0YW50IFwiJHtxKGVuY29kaW5nKX1cImAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH1cbmNhc2UnKyc6XG5jYXNlJy0nOntcbnJldHVybiBCaWdJbnQoZW5jb2RpbmcpO1xuIH1cbmNhc2UnJCc6e1xuY29uc3QgcmVzdWx0PWRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG4vKiBAdHMtaWdub3JlIFhYWCBTbWFsbENhcHNFbmNvZGluZyovXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3JlbW90YWJsZScpe1xuRmFpbCBgaW50ZXJuYWw6IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGEgcmVtb3RhYmxlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuY2FzZScmJzp7XG5jb25zdCByZXN1bHQ9ZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3Byb21pc2UnKXtcbkZhaWwgYGludGVybmFsOiBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYSBwcm9taXNlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBTcGVjaWFsIGNoYXIgJHtxKFxuYylcbiB9IHJlc2VydmVkIGZvciBmdXR1cmUgdXNlOiAke2VuY29kaW5nfWA7XG4gfX1cblxuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihlbmNvZGluZz09PW51bGwpe1xucmV0dXJuIGVuY29kaW5nO1xuIH1cblxuaWYoaXNBcnJheShlbmNvZGluZykpe1xucmV0dXJuIGVuY29kaW5nLm1hcCgodmFsKT0+ZGVjb2RlRnJvbVNtYWxsY2Fwcyh2YWwpKTtcbiB9XG5cbmlmKGhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyN0YWcnKSl7XG5jb25zdHsnI3RhZyc6dGFnLHBheWxvYWQsLi4ucmVzdH09ZW5jb2Rpbmc7XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVmFsdWUgb2YgXCIjdGFnXCIsIHRoZSB0YWcsIG11c3QgYmUgYSBzdHJpbmc6ICR7ZW5jb2Rpbmd9YDtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGAjdGFnIHJlY29yZCB1bmV4cGVjdGVkIHByb3BlcnRpZXM6ICR7cShvd25LZXlzKHJlc3QpKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQoXG5kZWNvZGVGcm9tU21hbGxjYXBzKHRhZyksXG5kZWNvZGVGcm9tU21hbGxjYXBzKHBheWxvYWQpKTtcblxuIH1cblxuaWYoaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI2Vycm9yJykpe1xuY29uc3QgcmVzdWx0PWRlY29kZUVycm9yRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbnBhc3NTdHlsZU9mKHJlc3VsdCk9PT0nZXJyb3InfHxcbkZhaWwgYGludGVybmFsOiBkZWNvZGVFcnJvckZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGFuIGVycm9yOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5cbmNvbnN0IGRlY29kZUVudHJ5PShbZW5jb2RlZE5hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgZW5jb2RlZE5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbmVuY29kZWROYW1lKVxuIH0gb2YgJHtlbmNvZGluZ30gbXVzdCBiZSBhIHN0cmluZ2A7XG5lbmNvZGVkTmFtZS5jaGFyQXQoMCkhPT0nIyd8fFxuRmFpbCBgVW5yZWNvZ25pemVkIHJlY29yZCB0eXBlICR7cShlbmNvZGVkTmFtZSl9OiAke2VuY29kaW5nfWA7XG5jb25zdCBuYW1lPWRlY29kZUZyb21TbWFsbGNhcHMoZW5jb2RlZE5hbWUpO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBEZWNvZGVkIHByb3BlcnR5IG5hbWUgJHtuYW1lfSBmcm9tICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoZW5jb2RpbmcpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogdW5yZWNvZ25pemVkIEpTT04gdHlwZW9mICR7cShcbnR5cGVvZiBlbmNvZGluZylcbiB9OiAke2VuY29kaW5nfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZUZyb21TbWFsbGNhcHMpO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbmNvZGVUb1NtYWxsY2FwcyI6WyJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiXSwibWFrZURlY29kZUZyb21TbWFsbGNhcHMiOlsibWFrZURlY29kZUZyb21TbWFsbGNhcHMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAcE6fMmEsAABhLAAAKgAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc3siaW1wb3J0cyI6WyJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vZXJyb3JzIiwiLi9lbmNvZGVUb0NhcERhdGEuanMiXSwiZXhwb3J0cyI6WyJkZWNvZGVUb0p1c3RpbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBOYXQsZ2V0RXJyb3JDb25zdHJ1Y3Rvcixpc09iamVjdCxwYXNzYWJsZVN5bWJvbEZvck5hbWUscSxYLEZhaWwsUUNMQVNTOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7RW5jb2Rpbmd9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3N0cmluZ2lmeTpxdW90ZX09SlNPTjtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbmRlbnRlclxuICogQHByb3BlcnR5IHsob3BlbkJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBvcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gbGluZVxuICogQHByb3BlcnR5IHsodG9rZW46IHN0cmluZykgPT4gbnVtYmVyfSBuZXh0XG4gKiBAcHJvcGVydHkgeyhjbG9zZUJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBjbG9zZVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGRvbmVcbiAqL1xuXG4vKipcbiAqIEdlbmVyb3VzIHdoaXRlc3BhY2UgZm9yIHJlYWRhYmlsaXR5XG4gKlxuICogQHJldHVybnMge0luZGVudGVyfVxuICovXG5jb25zdCBtYWtlWWVzSW5kZW50ZXI9KCk9PntcbmNvbnN0IHN0cmluZ3M9W107XG5sZXQgbGV2ZWw9MDtcbmxldCBuZWVkU3BhY2U9ZmFsc2U7XG5jb25zdCBsaW5lPSgpPT57XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKCdcXG4nLCcgICcucmVwZWF0KGxldmVsKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT57XG5sZXZlbCs9MTtcbmlmKG5lZWRTcGFjZSl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKG9wZW5CcmFja2V0KTtcbiB9LFxubGluZSxcbm5leHQ6KHRva2VuKT0+e1xuaWYobmVlZFNwYWNlJiZ0b2tlbiE9PScsJyl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9dHJ1ZTtcbnJldHVybiBzdHJpbmdzLnB1c2godG9rZW4pO1xuIH0sXG5jbG9zZTooY2xvc2VCcmFja2V0KT0+e1xuYXNzZXJ0KGxldmVsPj0xKTtcbmxldmVsLT0xO1xubGluZSgpO1xucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT57XG5hc3NlcnQuZXF1YWwobGV2ZWwsMCk7XG5yZXR1cm4gc3RyaW5ncy5qb2luKCcnKTtcbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIElmIHRoZSBsYXN0IGNoYXJhY3RlciBvZiBvbmUgdG9rZW4gdG9nZXRoZXIgd2l0aCB0aGUgZmlyc3QgY2hhcmFjdGVyXG4gKiBvZiB0aGUgbmV4dCB0b2tlbiBtYXRjaGVzIHRoaXMgcGF0dGVybiwgdGhlbiB0aGUgdHdvIHRva2VucyBtdXN0IGJlXG4gKiBzZXBhcmF0ZWQgYnkgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZSB0aGVpciBtZWFuaW5nLiBPdGhlcndpc2UgdGhlXG4gKiB3aGl0ZXNwYWNlIGluIHVubmVjZXNzYXJ5LlxuICpcbiAqIFRoZSBgPCFgIGFuZCBgLT5gIGNhc2VzIHByZXZlbnQgdGhlIGFjY2lkZW50YWwgZm9ybWF0aW9uIG9mIGFuXG4gKiBodG1sLWxpa2UgY29tbWVudC4gSSBkb24ndCB0aGluayB0aGUgZG91YmxlIGFuZ2xlIGJyYWNrZXRzIGFyZSBhY3R1YWxseVxuICogbmVlZGVkIGJ1dCBJIGhhdmVuJ3QgdGhvdWdodCBhYm91dCBpdCBlbm91Z2ggdG8gcmVtb3ZlIHRoZW0uXG4gKi9cbmNvbnN0IGJhZFBhaXJQYXR0ZXJuPS9eKD86XFx3XFx3fDw8fD4+fFxcK1xcK3wtLXw8IXwtPikkLztcblxuLyoqXG4gKiBNaW5pbXVtIHdoaXRlc3BhY2UgbmVlZGVkIHRvIHByZXNldmUgbWVhbmluZy5cbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VOb0luZGVudGVyPSgpPT57XG4vKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuY29uc3Qgc3RyaW5ncz1bXTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT5zdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpLFxubGluZTooKT0+c3RyaW5ncy5sZW5ndGgsXG5uZXh0Oih0b2tlbik9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xKXtcbmNvbnN0IGxhc3Q9c3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzIC0tIGVycm9yKi9cbmlmKGxhc3QubGVuZ3RoPj0xJiZ0b2tlbi5sZW5ndGg+PTEpe1xuY29uc3QgcGFpcj0gYCR7bGFzdFtsYXN0Lmxlbmd0aC0xXX0ke3Rva2VuWzBdfWA7XG5pZihiYWRQYWlyUGF0dGVybi50ZXN0KHBhaXIpKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbiB9XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5pZihzdHJpbmdzLmxlbmd0aD49MSYmc3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXT09PScsJyl7XG5zdHJpbmdzLnBvcCgpO1xuIH1cbnJldHVybiBzdHJpbmdzLnB1c2goY2xvc2VCcmFja2V0KTtcbiB9LFxuZG9uZTooKT0+c3RyaW5ncy5qb2luKCcnKX0pO1xuXG4gfTtcblxuY29uc3QgaWRlbnRQYXR0ZXJuPS9eW2EtekEtWl1cXHcqJC87XG5oYXJkZW4oaWRlbnRQYXR0ZXJuKTtcbmNvbnN0IEF0QXRQcmVmaXhQYXR0ZXJuPS9eQEAoLiopJC87XG5oYXJkZW4oQXRBdFByZWZpeFBhdHRlcm4pO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kaW5nXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBzaG91bGRJbmRlbnRcbiAqIEBwYXJhbSB7YW55W119IFtzbG90c11cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGRlY29kZVRvSnVzdGluPShlbmNvZGluZyxzaG91bGRJbmRlbnQ9ZmFsc2Usc2xvdHM9W10pPT57XG4vKipcbiAqIFRoZSBmaXJzdCBwYXNzIGRvZXMgc29tZSBpbnB1dCB2YWxpZGF0aW9uLlxuICogSXRzIGNvbnRyb2wgZmxvdyBzaG91bGQgbWlycm9yIGByZWN1cmAgYXMgY2xvc2VseSBhcyBwb3NzaWJsZVxuICogYW5kIHRoZSB0d28gc2hvdWxkIGJlIG1haW50YWluZWQgdG9nZXRoZXIuIFRoZXkgbXVzdCB2aXNpdCBldmVyeXRoaW5nXG4gKiBpbiB0aGUgc2FtZSBvcmRlci5cbiAqXG4gKiBUT0RPIG5vdyB0aGF0IGliaWRzIGFyZSBnb25lLCB3ZSBzaG91bGQgZm9sZCB0aGlzIGJhY2sgdG9nZXRoZXIgaW50b1xuICogb25lIHZhbGlkYXRpbmcgcGFzcy5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgcHJlcGFyZT0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG5yZXR1cm47XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBxY2xhc3MgdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG5yZXR1cm47XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbnJldHVybjtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKHRhZywnc3RyaW5nJyk7XG5wcmVwYXJlKHBheWxvYWQpO1xucmV0dXJuO1xuIH1cbmNhc2Unc2xvdCc6e1xuY29uc3R7aW5kZXgsaWZhY2V9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbk5hdChpbmRleCk7XG5pZihpZmFjZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKGlmYWNlLCdzdHJpbmcnKTtcbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xuJ29yaWdpbmFsJ2luIHJhd1RyZWV8fFxuRmFpbCBgSW52YWxpZCBIaWxiZXJ0IEhvdGVsIGVuY29kaW5nICR7cmF3VHJlZX1gO1xucHJlcGFyZShvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmlmKHR5cGVvZiByZXN0IT09J29iamVjdCcpe1xudGhyb3cgRmFpbCBgUmVzdCAke3Jlc3R9IGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0YDtcbiB9XG5pZihyZXN0PT09bnVsbCl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgbnVsbGA7XG4gfVxuaWYoaXNBcnJheShyZXN0KSl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgYW4gYXJyYXlgO1xuIH1cbmlmKFFDTEFTUyBpbiByZXN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgJHtyZXN0fSBtdXN0IG5vdCBjb250YWluICR7cShRQ0xBU1MpfWA7XG4gfVxuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbnR5cGVvZiBuYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG5wcmVwYXJlKHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgbmFtZSl9YDtcbiB9XG5nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpIT09dW5kZWZpbmVkfHxcbkZhaWwgYE11c3QgYmUgdGhlIG5hbWUgb2YgYW4gRXJyb3IgY29uc3RydWN0b3IgJHtuYW1lfWA7XG50eXBlb2YgbWVzc2FnZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbWVzc2FnZSB0eXBlb2YgJHtxKHR5cGVvZiBtZXNzYWdlKX1gO1xucmV0dXJuO1xuIH1cblxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbnByZXBhcmUocmF3VHJlZVtpXSk7XG4gfVxuIH1lbHNle1xuY29uc3QgbmFtZXM9b3duS2V5cyhyYXdUcmVlKTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbmlmKHR5cGVvZiBuYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG4gfVxucHJlcGFyZShyYXdUcmVlW25hbWVdKTtcbiB9XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VJbmRlbnRlcj1zaG91bGRJbmRlbnQ/bWFrZVllc0luZGVudGVyOm1ha2VOb0luZGVudGVyO1xubGV0IG91dD1tYWtlSW5kZW50ZXIoKTtcblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBzZWNvbmQgcGFzcyByZWN1cnNpb24gYWZ0ZXIgdGhlIGZpcnN0IHBhc3MgYHByZXBhcmVgLlxuICogVGhlIGZpcnN0IHBhc3MgZGlkIHNvbWUgaW5wdXQgdmFsaWRhdGlvbiBzb1xuICogaGVyZSB3ZSBjYW4gc2FmZWx5IGFzc3VtZSBldmVyeXRoaW5nIHRob3NlIHRoaW5ncyBhcmUgdmFsaWRhdGVkLlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHtudW1iZXJ9XG4gKi9cbmNvbnN0IGRlY29kZT0ocmF3VHJlZSk9Pntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gcmVjdXIocmF3VHJlZSk7XG4gfTtcblxuY29uc3QgZGVjb2RlUHJvcGVydHk9KG5hbWUsdmFsdWUpPT57XG5vdXQubGluZSgpO1xuaWYobmFtZT09PSdfX3Byb3RvX18nKXtcbi8qIEphdmFTY3JpcHQgaW50ZXJwcmV0cyBge19fcHJvdG9fXzogeCwgLi4ufWAqL1xuLyogYXMgbWFraW5nIGFuIG9iamVjdCBpbmhlcml0aW5nIGZyb20gYHhgLCB3aGVyZWFzKi9cbi8qIGluIEpTT04gaXQgaXMgc2ltcGx5IGEgcHJvcGVydHkgbmFtZS4gUHJlc2VydmUgdGhlKi9cbi8qIEpTT04gbWVhbmluZy4qL1xub3V0Lm5leHQoIGBbXCJfX3Byb3RvX19cIl06YCk7XG4gfWVsc2UgaWYoaWRlbnRQYXR0ZXJuLnRlc3QobmFtZSkpe1xub3V0Lm5leHQoIGAke25hbWV9OmApO1xuIH1lbHNle1xub3V0Lm5leHQoIGAke3F1b3RlKG5hbWUpfTpgKTtcbiB9XG5kZWNvZGUodmFsdWUpO1xub3V0Lm5leHQoJywnKTtcbiB9O1xuXG4vKipcbiAqIE1vZGVsZWQgYWZ0ZXIgYGZ1bGxSZXZpdmVgIGluIG1hcnNoYWwuanNcbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCByZWN1cj0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG4vKiBwcmltaXRpdmVzIGdldCBxdW90ZWQqL1xucmV0dXJuIG91dC5uZXh0KHF1b3RlKHJhd1RyZWUpKTtcbiB9XG4vKiBBc3NlcnRpb25zIG9mIHRoZSBhYm92ZSB0byBuYXJyb3cgdGhlIHR5cGUuKi9cbmFzc2VydC50eXBlb2YocmF3VHJlZSwnb2JqZWN0Jyk7XG5hc3NlcnQocmF3VHJlZSE9PW51bGwpO1xuaWYoUUNMQVNTIGluIHJhd1RyZWUpe1xuY29uc3QgcWNsYXNzPXJhd1RyZWVbUUNMQVNTXTtcbmFzc2VydC50eXBlb2YocWNsYXNzLCdzdHJpbmcnKTtcbmFzc2VydCghaXNBcnJheShyYXdUcmVlKSk7XG4vKiBTd2l0Y2hpbmcgb24gYGVuY29kZWRbUUNMQVNTXWAgKG9yIGFueXRoaW5nIGxlc3MgZGlyZWN0LCBsaWtlKi9cbi8qIGBxY2xhc3NgKSBkb2VzIG5vdCBkaXNjcmltaW5hdGUgcmF3VHJlZSBpbiB0eXBlc2NyaXB0QDQuMi4zIGFuZCovXG4vKiBlYXJsaWVyLiovXG5zd2l0Y2gocmF3VHJlZVsnQHFjbGFzcyddKXtcbi8qIEVuY29kaW5nIG9mIHByaW1pdGl2ZXMgbm90IGhhbmRsZWQgYnkgSlNPTiovXG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ05hTic6XG5jYXNlJ0luZmluaXR5JzpcbmNhc2UnLUluZmluaXR5Jzp7XG4vKiBUaGVpciBxY2xhc3MgaXMgdGhlaXIgZXhwcmVzc2lvbiBzb3VyY2UuKi9cbnJldHVybiBvdXQubmV4dChxY2xhc3MpO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGRpZ2l0cywnc3RyaW5nJyk7XG5yZXR1cm4gb3V0Lm5leHQoIGAke0JpZ0ludChkaWdpdHMpfW5gKTtcbiB9XG5jYXNlJ0BAYXN5bmNJdGVyYXRvcic6e1xuLyogVE9ETyBkZXByZWNhdGVkLiBFdmVudHVhbGx5IHJlbW92ZS4qL1xucmV0dXJuIG91dC5uZXh0KCdTeW1ib2wuYXN5bmNJdGVyYXRvcicpO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5jb25zdHtuYW1lfT1yYXdUcmVlO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbmNvbnN0IHN5bT1wYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG5hc3NlcnQudHlwZW9mKHN5bSwnc3ltYm9sJyk7XG5jb25zdCByZWdpc3RlcmVkTmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihyZWdpc3RlcmVkTmFtZT09PXVuZGVmaW5lZCl7XG5jb25zdCBtYXRjaD1BdEF0UHJlZml4UGF0dGVybi5leGVjKG5hbWUpO1xuYXNzZXJ0KG1hdGNoIT09bnVsbCk7XG5jb25zdCBzdWZmaXg9bWF0Y2hbMV07XG5hc3NlcnQoU3ltYm9sW3N1ZmZpeF09PT1zeW0pO1xuYXNzZXJ0KGlkZW50UGF0dGVybi50ZXN0KHN1ZmZpeCkpO1xucmV0dXJuIG91dC5uZXh0KCBgU3ltYm9sLiR7c3VmZml4fWApO1xuIH1cbnJldHVybiBvdXQubmV4dCggYFN5bWJvbC5mb3IoJHtxdW90ZShyZWdpc3RlcmVkTmFtZSl9KWApO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdHt0YWcscGF5bG9hZH09cmF3VHJlZTtcbm91dC5uZXh0KCBgbWFrZVRhZ2dlZCgke3F1b3RlKHRhZyl9LGApO1xuZGVjb2RlKHBheWxvYWQpO1xucmV0dXJuIG91dC5uZXh0KCcpJyk7XG4gfVxuXG5jYXNlJ3Nsb3QnOntcbmxldHtpZmFjZX09cmF3VHJlZTtcbmNvbnN0IGluZGV4PU51bWJlcihOYXQocmF3VHJlZS5pbmRleCkpO1xuY29uc3QgbmVzdGVkUmVuZGVyPShhcmcpPT57XG5jb25zdCBvbGRPdXQ9b3V0O1xudHJ5e1xub3V0PW1ha2VOb0luZGVudGVyKCk7XG5kZWNvZGUoYXJnKTtcbnJldHVybiBvdXQuZG9uZSgpO1xuIH1maW5hbGx5e1xub3V0PW9sZE91dDtcbiB9XG4gfTtcbmlmKGluZGV4PHNsb3RzLmxlbmd0aCl7XG5jb25zdCBzbG90PW5lc3RlZFJlbmRlcihzbG90c1tpbmRleF0pO1xuaWYoaWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdFRvVmFsKCR7c2xvdH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3RUb1ZhbCgke3Nsb3R9LCR7aWZhY2V9KWApO1xuIH1lbHNlIGlmKGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0sJHtpZmFjZX0pYCk7XG4gfVxuXG5jYXNlJ2hpbGJlcnQnOntcbmNvbnN0e29yaWdpbmFsLHJlc3R9PXJhd1RyZWU7XG5vdXQub3BlbigneycpO1xuZGVjb2RlUHJvcGVydHkoUUNMQVNTLG9yaWdpbmFsKTtcbmlmKCdyZXN0J2luIHJhd1RyZWUpe1xuYXNzZXJ0LnR5cGVvZihyZXN0LCdvYmplY3QnKTtcbmFzc2VydChyZXN0IT09bnVsbCk7XG5jb25zdCBuYW1lcz1vd25LZXlzKHJlc3QpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbm5hbWUpXG4gfSBvZiAke3Jlc3R9IG11c3QgYmUgYSBzdHJpbmdgO1xuIH1cbmRlY29kZVByb3BlcnR5KG5hbWUscmVzdFtuYW1lXSk7XG4gfVxuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG5cbmNhc2UnZXJyb3InOntcbmNvbnN0e1xubmFtZSxcbm1lc3NhZ2UsXG5jYXVzZT11bmRlZmluZWQsXG5lcnJvcnM9dW5kZWZpbmVkfT1cbnJhd1RyZWU7XG5jYXVzZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBjYXVzZSBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbm5hbWUhPT0gYEFnZ3JlZ2F0ZUVycm9yYHx8XG5GYWlsIGBBZ2dyZWdhdGVFcnJvciBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbmVycm9ycz09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBlcnJvcnMgbm90IHlldCBpbXBsZW1lbnRlZCBpbiBtYXJzaGFsLWp1c3RpbmA7XG5yZXR1cm4gb3V0Lm5leHQoIGAke25hbWV9KCR7cXVvdGUobWVzc2FnZSl9KWApO1xuIH1cblxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgnW10nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCdbJyk7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbm91dC5saW5lKCk7XG5kZWNvZGUocmF3VHJlZVtpXSk7XG5vdXQubmV4dCgnLCcpO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ10nKTtcbiB9XG4gfWVsc2V7XG4vKiByYXdUcmVlIGlzIGFuIGBFbmNvZGluZ1JlY29yZGAgd2hpY2ggb25seSBoYXMgc3RyaW5nIGtleXMsKi9cbi8qIGJ1dCBzaW5jZSBvd25LZXlzIGlzIG5vdCBnZW5lcmljLCBpdCBjYW4ndCBwcm9wYWdhdGUgdGhhdCovXG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmF3VHJlZSk7XG5pZihuYW1lcy5sZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgne30nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCd7Jyk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJhd1RyZWVbbmFtZV0pO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG4gfVxuIH07XG5wcmVwYXJlKGVuY29kaW5nKTtcbmRlY29kZShlbmNvZGluZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9OyRozY9fb25jZS5kZWNvZGVUb0p1c3RpbihkZWNvZGVUb0p1c3Rpbik7XG5oYXJkZW4oZGVjb2RlVG9KdXN0aW4pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVjb2RlVG9KdXN0aW4iOlsiZGVjb2RlVG9KdXN0aW4iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL21hcnNoYWwuanMiXSwiZXhwb3J0cyI6WyJwYXJzZSIsInN0cmluZ2lmeSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLG1ha2VNYXJzaGFsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL21hcnNoYWwuanNcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaM2PX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEBpbXBvcnQge1Bhc3NhYmxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFZhbFRvU2xvdD0odmFsKT0+XG5GYWlsIGBNYXJzaGFsJ3Mgc3RyaW5naWZ5IHJlamVjdHMgcHJlc2VuY2VzIGFuZCBwcm9taXNlcyAke3ZhbH1gO1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFNsb3RUb1ZhbD0oc2xvdCxfaWZhY2UpPT5cbkZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3RzICR7c2xvdH1gO1xuXG5jb25zdCBiYWRBcnJheUhhbmRsZXI9aGFyZGVuKHtcbmdldDooX3RhcmdldCxuYW1lLF9yZWNlaXZlcik9PntcbmlmKG5hbWU9PT0nbGVuZ3RoJyl7XG5yZXR1cm4gMDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBNYXJzaGFsJ3MgcGFyc2UgbXVzdCBub3QgZW5jb2RlIGFueSBzbG90IHBvc2l0aW9ucyAke25hbWV9YDtcbiB9fSk7XG5cblxuY29uc3QgYmFkQXJyYXk9aGFyZGVuKG5ldyBQcm94eShoYXJkZW4oW10pLGJhZEFycmF5SGFuZGxlcikpO1xuXG5jb25zdHtzZXJpYWxpemUsdW5zZXJpYWxpemV9PW1ha2VNYXJzaGFsKFxuZG9Ob3RDb252ZXJ0VmFsVG9TbG90LFxuZG9Ob3RDb252ZXJ0U2xvdFRvVmFsLFxue1xuZXJyb3JUYWdnaW5nOidvZmYnLFxuLyogVE9ETyBmaXggdGVzdHMgdG8gd29ya3Mgd2l0aCBzbWFsbGNhcHMuKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J2NhcGRhdGEnfSk7XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3Qgc3RyaW5naWZ5PSh2YWwpPT5zZXJpYWxpemUodmFsKS5ib2R5OyRozY9fb25jZS5zdHJpbmdpZnkoc3RyaW5naWZ5KTtcbmhhcmRlbihzdHJpbmdpZnkpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJcbiAqIEByZXR1cm5zIHt1bmtub3dufVxuICovXG5jb25zdCBwYXJzZT0oc3RyKT0+XG51bnNlcmlhbGl6ZShcbmhhcmRlbih7XG5ib2R5OnN0cixcbnNsb3RzOmJhZEFycmF5fSkpOyRozY9fb25jZS5wYXJzZShwYXJzZSk7XG5cblxuaGFyZGVuKHBhcnNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0cmluZ2lmeSI6WyJzdHJpbmdpZnkiXSwicGFyc2UiOlsicGFyc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAE7Fc3pk3AACZNwAAIwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzeyJpbXBvcnRzIjpbIkBlbmRvL25hdCIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9lcnJvcnMiLCJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyIsIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9lbmNvZGVUb1NtYWxsY2Fwcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VNYXJzaGFsIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IE5hdCxhc3NlcnRQYXNzYWJsZSxnZXRJbnRlcmZhY2VPZixnZXRFcnJvckNvbnN0cnVjdG9yLGhhc093blByb3BlcnR5T2YsdG9QYXNzYWJsZUVycm9yLFgsRmFpbCxxLG1ha2VFcnJvcixhbm5vdGF0ZUVycm9yLG9iamVjdE1hcCxRQ0xBU1MsbWFrZUVuY29kZVRvQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbUNhcERhdGEsbWFrZURlY29kZUZyb21TbWFsbGNhcHMsbWFrZUVuY29kZVRvU21hbGxjYXBzOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaM2PX2EpXV0sW1wiZ2V0SW50ZXJmYWNlT2ZcIiwgWyRozY9fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJ0b1Bhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAodG9QYXNzYWJsZUVycm9yID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJtYWtlRXJyb3JcIiwgWyRozY9fYSA9PiAobWFrZUVycm9yID0gJGjNj19hKV1dLFtcImFubm90YXRlRXJyb3JcIiwgWyRozY9fYSA9PiAoYW5ub3RhdGVFcnJvciA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2NvbW1vbi9vYmplY3QtbWFwLmpzXCIsIFtbXCJvYmplY3RNYXBcIiwgWyRozY9fYSA9PiAob2JqZWN0TWFwID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV0sW1wibWFrZUVuY29kZVRvQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRW5jb2RlVG9DYXBEYXRhID0gJGjNj19hKV1dLFtcIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbUNhcERhdGEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVRvU21hbGxjYXBzLmpzXCIsIFtbXCJtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwc1wiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyA9ICRozY9fYSldXSxbXCJtYWtlRW5jb2RlVG9TbWFsbGNhcHNcIiwgWyRozY9fYSA9PiAobWFrZUVuY29kZVRvU21hbGxjYXBzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDb252ZXJ0U2xvdFRvVmFsLCBDb252ZXJ0VmFsVG9TbG90LCBGcm9tQ2FwRGF0YSwgTWFrZU1hcnNoYWxPcHRpb25zLCBUb0NhcERhdGF9IGZyb20gJy4vdHlwZXMuanMnO1xuICogQGltcG9ydCB7UGFzc2FibGUsIFBhc3NhYmxlQ2FwLCBSZW1vdGFibGVPYmplY3R9IGZyb20gJ0BlbmRvL3Bhc3Mtc3R5bGUnO1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlY30gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSc7XG4gKiBAaW1wb3J0IHtFbmNvZGluZ30gZnJvbSAnLi90eXBlcy5qcyc7XG4gKi9cblxuY29uc3R7ZGVmaW5lUHJvcGVydGllc309T2JqZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge0NvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRWYWxUb1Nsb3RGbj0oeCk9Png7XG4vKiogQHR5cGUge0NvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRTbG90VG9WYWxGbj0oeCxfKT0+eDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgU2xvdFxuICogQHBhcmFtIHtDb252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBbY29udmVydFZhbFRvU2xvdF1cbiAqIEBwYXJhbSB7Q29udmVydFNsb3RUb1ZhbDxTbG90Pn0gW2NvbnZlcnRTbG90VG9WYWxdXG4gKiBAcGFyYW0ge01ha2VNYXJzaGFsT3B0aW9uc30gb3B0aW9uc1xuICovXG5jb25zdCAgICAgICAgbWFrZU1hcnNoYWw9KFxuY29udmVydFZhbFRvU2xvdD1kZWZhdWx0VmFsVG9TbG90Rm4sXG5jb252ZXJ0U2xvdFRvVmFsPWRlZmF1bHRTbG90VG9WYWxGbixcbntcbmVycm9yVGFnZ2luZz0nb24nLFxubWFyc2hhbE5hbWU9J2Fub24tbWFyc2hhbCcsXG4vKiBUT0RPIFRlbXBvcmFyeSBoYWNrLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8yNzgwKi9cbmVycm9ySWROdW09MTAwMDAsXG4vKiBXZSBwcmVmZXIgdGhhdCB0aGUgY2FsbGVyIGluc3RlYWQgbG9nIHRvIHNvbWV3aGVyZSBoaWRkZW4qL1xuLyogdG8gYmUgcmV2ZWFsZWQgd2hlbiBjb3JyZWxhdGluZyB3aXRoIHRoZSByZWNlaXZlZCBlcnJvci4qL1xubWFyc2hhbFNhdmVFcnJvcj0oZXJyKT0+XG5jb25zb2xlLmxvZygnVGVtcG9yYXJ5IGxvZ2dpbmcgb2Ygc2VudCBlcnJvcicsZXJyKSxcbi8qIERlZmF1bHQgdG8gJ2NhcGRhdGEnIGJlY2F1c2UgaXQgd2FzIGltcGxlbWVudGVkIGZpcnN0LiovXG4vKiBTb21ldGltZXMsIG9udG9nZW55IGRvZXMgcmVjYXBpdHVsYXRlIHBoeWxvZ2VueSA7KSovXG5zZXJpYWxpemVCb2R5Rm9ybWF0PSdjYXBkYXRhJ309XG57fSk9Plxue1xuYXNzZXJ0LnR5cGVvZihtYXJzaGFsTmFtZSwnc3RyaW5nJyk7XG5lcnJvclRhZ2dpbmc9PT0nb24nfHxcbmVycm9yVGFnZ2luZz09PSdvZmYnfHxcbkZhaWwgYFRoZSBlcnJvclRhZ2dpbmcgb3B0aW9uIGNhbiBvbmx5IGJlIFwib25cIiBvciBcIm9mZlwiICR7ZXJyb3JUYWdnaW5nfWA7XG5jb25zdCBuZXh0RXJyb3JJZD0oKT0+e1xuZXJyb3JJZE51bSs9MTtcbnJldHVybiBgZXJyb3I6JHttYXJzaGFsTmFtZX0jJHtlcnJvcklkTnVtfWA7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7VG9DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCB0b0NhcERhdGE9KHJvb3QpPT57XG5jb25zdCBzbG90cz1bXTtcbi8qIG1hcHMgdmFsIChwcm9taXNlIG9yIHJlbW90YWJsZSkgdG8gaW5kZXggb2Ygc2xvdHNbXSovXG5jb25zdCBzbG90TWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHJldHVybnMge3tpbmRleDogbnVtYmVyLCByZXBlYXQ6IGJvb2xlYW59fVxuICovXG5jb25zdCBlbmNvZGVTbG90Q29tbW9uPShwYXNzYWJsZSk9PntcbmxldCBpbmRleD1zbG90TWFwLmdldChwYXNzYWJsZSk7XG5pZihpbmRleCE9PXVuZGVmaW5lZCl7XG4vKiBUT0RPIGFzc2VydCB0aGF0IGl0J3MgdGhlIHNhbWUgaWZhY2UgYXMgYmVmb3JlKi9cbmFzc2VydC50eXBlb2YoaW5kZXgsJ251bWJlcicpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OnRydWV9KTtcbiB9XG5cbmluZGV4PXNsb3RzLmxlbmd0aDtcbmNvbnN0IHNsb3Q9Y29udmVydFZhbFRvU2xvdChwYXNzYWJsZSk7XG5zbG90cy5wdXNoKHNsb3QpO1xuc2xvdE1hcC5zZXQocGFzc2FibGUsaW5kZXgpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OmZhbHNlfSk7XG4gfTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiB1bmtub3dufSBlbmNvZGVSZWN1clxuICogQHJldHVybnMge3tlcnJvcklkPzogc3RyaW5nLCBtZXNzYWdlOiBzdHJpbmcsIG5hbWU6IHN0cmluZ319XG4gKi9cbmNvbnN0IGVuY29kZUVycm9yQ29tbW9uPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBtZXNzYWdlPWVuY29kZVJlY3VyKCBgJHtlcnIubWVzc2FnZX1gKTtcbmFzc2VydC50eXBlb2YobWVzc2FnZSwnc3RyaW5nJyk7XG5jb25zdCBuYW1lPWVuY29kZVJlY3VyKCBgJHtlcnIubmFtZX1gKTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG4vKiBUT0RPIE11c3QgZW5jb2RlIGBjYXVzZWAsIGBlcnJvcnNgLCBidXQqL1xuLyogb25seSBvbmNlIGFsbCBwb3NzaWJsZSBjb3VudGVycGFydHkgZGVjb2RlcnMgYXJlIHRvbGVyYW50IG9mKi9cbi8qIHJlY2VpdmluZyB0aGVtLiovXG5pZihlcnJvclRhZ2dpbmc9PT0nb24nKXtcbi8qIFdlIGRlbGliZXJhdGVseSBkbyBub3Qgc2hhcmUgdGhlIHN0YWNrLCBidXQgaXQgd291bGQqL1xuLyogYmUgdXNlZnVsIHRvIGxvZyB0aGUgc3RhY2sgbG9jYWxseSBzbyBzb21lb25lIHdobyBoYXMqL1xuLyogcHJpdmlsZWdlZCBhY2Nlc3MgdG8gdGhlIHRocm93aW5nIFZhdCBjYW4gY29ycmVsYXRlKi9cbi8qIHRoZSBwcm9ibGVtIHdpdGggdGhlIHJlbW90ZSBWYXQgdGhhdCBnZXRzIHRoaXMqL1xuLyogc3VtbWFyeS4gSWYgd2UgZG8gdGhhdCwgd2UgY291bGQgYWxsb2NhdGUgc29tZSByYW5kb20qL1xuLyogaWRlbnRpZmllciBhbmQgaW5jbHVkZSBpdCBpbiB0aGUgbWVzc2FnZSwgdG8gaGVscCovXG4vKiB3aXRoIHRoZSBjb3JyZWxhdGlvbi4qL1xuY29uc3QgZXJyb3JJZD1lbmNvZGVSZWN1cihuZXh0RXJyb3JJZCgpKTtcbmFzc2VydC50eXBlb2YoZXJyb3JJZCwnc3RyaW5nJyk7XG5hbm5vdGF0ZUVycm9yKGVycixYIGBTZW50IGFzICR7ZXJyb3JJZH1gKTtcbm1hcnNoYWxTYXZlRXJyb3IoZXJyKTtcbnJldHVybiBoYXJkZW4oe2Vycm9ySWQsbWVzc2FnZSxuYW1lfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHttZXNzYWdlLG5hbWV9KTtcbiB9XG4gfTtcblxuaWYoc2VyaWFsaXplQm9keUZvcm1hdD09PSdjYXBkYXRhJyl7XG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVDYXB9IHBhc3NhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV1cbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlU2xvdFRvQ2FwRGF0YT0ocGFzc2FibGUsaWZhY2U9dW5kZWZpbmVkKT0+e1xuY29uc3R7aW5kZXgscmVwZWF0fT1lbmNvZGVTbG90Q29tbW9uKHBhc3NhYmxlKTtcblxuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J3Nsb3QnLGluZGV4fSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtbUUNMQVNTXTonc2xvdCcsaWZhY2UsaW5kZXh9KTtcbiB9XG4gfTtcblxuLyoqIEB0eXBlIHsocHJvbWlzZTogUmVtb3RhYmxlT2JqZWN0LCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHZhbCxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb0NhcERhdGEodmFsLGdldEludGVyZmFjZU9mKHZhbCkpO1xuXG4vKiogQHR5cGUgeyhwcm9taXNlOiBQcm9taXNlLCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9taXNlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YShwcm9taXNlKTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ30gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidlcnJvcicsLi4uZXJyRGF0YX0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvQ2FwRGF0YT1tYWtlRW5jb2RlVG9DYXBEYXRhKHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IGVuY29kZWQ9ZW5jb2RlVG9DYXBEYXRhKHJvb3QpO1xuY29uc3QgYm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuYm9keSxcbnNsb3RzfSk7XG5cbiB9ZWxzZSBpZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J3NtYWxsY2Fwcycpe1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcHJlZml4XG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9TbWFsbGNhcHM9KHByZWZpeCxwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG4vKiBUT0RPIGV4cGxvcmUgcmVtb3ZpbmcgdGhpcyBzcGVjaWFsIGNhc2UqL1xuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fWA7XG4gfVxucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fS4ke2lmYWNlfWA7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbW90YWJsZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJCcscmVtb3RhYmxlLGdldEludGVyZmFjZU9mKHJlbW90YWJsZSkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9TbWFsbGNhcHMoJyYnLHByb21pc2UpO1xuXG5jb25zdCBlbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBlcnJEYXRhPWVuY29kZUVycm9yQ29tbW9uKGVycixlbmNvZGVSZWN1cik7XG5jb25zdHttZXNzYWdlLC4uLnJlc3R9PWVyckRhdGE7XG5yZXR1cm4gaGFyZGVuKHsnI2Vycm9yJzptZXNzYWdlLC4uLnJlc3R9KTtcbiB9O1xuXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwcz1tYWtlRW5jb2RlVG9TbWFsbGNhcHMoe1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb1NtYWxsY2Fwcyhyb290KTtcbmNvbnN0IHNtYWxsY2Fwc0JvZHk9SlNPTi5zdHJpbmdpZnkoZW5jb2RlZCk7XG5yZXR1cm4gaGFyZGVuKHtcbi8qIFZhbGlkIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYSB2YWxpZCBzaWduYWwqL1xuLyogaW5kaWNhdGluZyBzbWFsbGNhcHMgZm9ybWF0LiovXG5ib2R5OiBgIyR7c21hbGxjYXBzQm9keX1gLFxuc2xvdHN9KTtcblxuIH1lbHNle1xuLyogVGhlIGB0aHJvd2AgaXMgYSBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEFkZGVkIGZvciBjb25mdXNlZCBsaW50ZXJzLiovXG50aHJvdyBGYWlsIGBVbnJlY29nbml6ZWQgc2VyaWFsaXplQm9keUZvcm1hdDogJHtxKHNlcmlhbGl6ZUJvZHlGb3JtYXQpfWA7XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VGdWxsUmV2aXZlPShzbG90cyk9Pntcbi8qKiBAdHlwZSB7TWFwPG51bWJlciwgUmVtb3RhYmxlT2JqZWN0IHwgUHJvbWlzZT59ICovXG5jb25zdCB2YWxNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7e2lmYWNlPzogc3RyaW5nLCBpbmRleDogbnVtYmVyfX0gc2xvdERhdGFcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5jb25zdCBkZWNvZGVTbG90Q29tbW9uPShzbG90RGF0YSk9PntcbmNvbnN0e2lmYWNlPXVuZGVmaW5lZCxpbmRleCwuLi5yZXN0fT1zbG90RGF0YTtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgc2xvdCBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuY29uc3QgZXh0YW50PXZhbE1hcC5nZXQoaW5kZXgpO1xuaWYoZXh0YW50KXtcbnJldHVybiBleHRhbnQ7XG4gfVxuLyogVE9ETyBTRUNVUklUWSBIQVpBUkQ6IG11c3QgZW5mb2NlIHRoYXQgcmVtb3RhYmxlIHZzIHByb21pc2UqL1xuLyogaXMgYWNjb3JkaW5nIHRvIHRoZSBlbmNvZGVkIHN0cmluZy4qL1xuY29uc3Qgc2xvdD1zbG90c1tOdW1iZXIoTmF0KGluZGV4KSldO1xuY29uc3QgdmFsPWNvbnZlcnRTbG90VG9WYWwoc2xvdCxpZmFjZSk7XG52YWxNYXAuc2V0KGluZGV4LHZhbCk7XG5yZXR1cm4gdmFsO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHt7XG4gKiAgIGVycm9ySWQ/OiBzdHJpbmcsXG4gKiAgIG1lc3NhZ2U6IHN0cmluZyxcbiAqICAgbmFtZTogc3RyaW5nLFxuICogICBjYXVzZTogdW5rbm93bixcbiAqICAgZXJyb3JzOiB1bmtub3duLFxuICogfX0gZXJyRGF0YVxuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IGRlY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0IGRlY29kZUVycm9yQ29tbW9uPShlcnJEYXRhLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7XG5lcnJvcklkPXVuZGVmaW5lZCxcbm1lc3NhZ2UsXG5uYW1lLFxuY2F1c2U9dW5kZWZpbmVkLFxuZXJyb3JzPXVuZGVmaW5lZCxcbi4uLnJlc3R9PVxuZXJyRGF0YTtcbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8yMDUyKi9cbi8qIGNhcERhdGEgZG9lcyBub3QgdHJhbnNmb3JtIHN0cmluZ3MuIFRoZSBpbW1lZGlhdGVseSBmb2xsb3dpbmcgY2FsbHMqL1xuLyogdG8gYGRlY29kZVJlY3VyYCBhcmUgZm9yIHJldXNlIGJ5IG90aGVyIGVuY29kaW5ncyB0aGF0IGRvLCovXG4vKiBzdWNoIGFzIHNtYWxsY2Fwcy4qL1xuY29uc3QgZE5hbWU9ZGVjb2RlUmVjdXIobmFtZSk7XG5jb25zdCBkTWVzc2FnZT1kZWNvZGVSZWN1cihtZXNzYWdlKTtcbi8qIGVycm9ySWQgaXMgYSBsYXRlIGFkZGl0aW9uIHNvIGJlIHRvbGVyYW50IG9mIGl0cyBhYnNlbmNlLiovXG5jb25zdCBkRXJyb3JJZD0vKiogQHR5cGUge3N0cmluZ30gKi9lcnJvcklkJiZkZWNvZGVSZWN1cihlcnJvcklkKTtcbmlmKHR5cGVvZiBkTmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBkTmFtZSl9YDtcbiB9XG5pZih0eXBlb2YgZE1lc3NhZ2UhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgZE1lc3NhZ2UpfWA7XG4gfVxuY29uc3QgZXJyQ29uc3RydWN0b3I9Z2V0RXJyb3JDb25zdHJ1Y3RvcihkTmFtZSl8fEVycm9yO1xuY29uc3QgZXJyb3JOYW1lPVxuZEVycm9ySWQ9PT11bmRlZmluZWQ/XG4gYFJlbW90ZSR7ZXJyQ29uc3RydWN0b3IubmFtZX1gOlxuIGBSZW1vdGUke2VyckNvbnN0cnVjdG9yLm5hbWV9KCR7ZEVycm9ySWR9KWA7XG5jb25zdCBvcHRpb25zPXtcbmVycm9yTmFtZSxcbnNhbml0aXplOmZhbHNlfTtcblxuaWYoY2F1c2Upe1xub3B0aW9ucy5jYXVzZT1kZWNvZGVSZWN1cihjYXVzZSk7XG4gfVxuaWYoZXJyb3JzKXtcbm9wdGlvbnMuZXJyb3JzPWRlY29kZVJlY3VyKGVycm9ycyk7XG4gfVxuY29uc3QgcmF3RXJyb3I9bWFrZUVycm9yKGRNZXNzYWdlLGVyckNvbnN0cnVjdG9yLG9wdGlvbnMpO1xuLyogTm90ZSB0aGF0IHRoaXMgZG9lcyBub3QgZGVjb2RlUmVjdXIgcmVzdCdzIHByb3BlcnR5IG5hbWVzLiovXG4vKiBUaGlzIHdvdWxkIGJlIGluY29uc2lzdGVudCB3aXRoIHNtYWxsY2FwcycgZXhwZWN0ZWQgaGFuZGxpbmcsKi9cbi8qIGJ1dCBpcyBmaW5lIGhlcmUgc2luY2UgaXQgaXMgb25seSB1c2VkIGZvciBgYW5ub3RhdGVFcnJvcmAsKi9cbi8qIHdoaWNoIGlzIGZvciBkaWFnbm9zdGljIGluZm8gdGhhdCBpcyBvdGhlcndpc2UgdW5vYnNlcnZhYmxlLiovXG5jb25zdCBkZXNjcz1vYmplY3RNYXAocmVzdCwoZGF0YSk9Pih7XG52YWx1ZTpkZWNvZGVSZWN1cihkYXRhKSxcbndyaXRhYmxlOmZhbHNlLFxuZW51bWVyYWJsZTpmYWxzZSxcbmNvbmZpZ3VyYWJsZTpmYWxzZX0pKTtcblxuZGVmaW5lUHJvcGVydGllcyhyYXdFcnJvcixkZXNjcyk7XG5oYXJkZW4ocmF3RXJyb3IpO1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcihyYXdFcnJvcik7XG4gfTtcblxuLyogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaCovXG4vKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb24qL1xuLyogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUqL1xuLyogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNCovXG5jb25zdCBkZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0ocmF3VHJlZSxfZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLnNsb3REYXRhfT1yYXdUcmVlO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oc2xvdERhdGEpO1xuIH07XG5cbmNvbnN0IGRlY29kZUVycm9yRnJvbUNhcERhdGE9KHJhd1RyZWUsZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLmVyckRhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlRXJyb3JDb21tb24oZXJyRGF0YSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbUNhcERhdGE9bWFrZURlY29kZUZyb21DYXBEYXRhKHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IG1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2Fwcz0ocHJlZml4KT0+e1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyaW5nRW5jb2RpbmdcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBfZGVjb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5yZXR1cm4oc3RyaW5nRW5jb2RpbmcsX2RlY29kZVJlY3VyKT0+e1xuYXNzZXJ0KHN0cmluZ0VuY29kaW5nLmNoYXJBdCgwKT09PXByZWZpeCk7XG4vKiBzbG90czogJHNsb3RJbmRleC5pZmFjZSBvciAkc2xvdEluZGV4Ki9cbmNvbnN0IGk9c3RyaW5nRW5jb2RpbmcuaW5kZXhPZignLicpO1xuY29uc3QgaW5kZXg9TnVtYmVyKHN0cmluZ0VuY29kaW5nLnNsaWNlKDEsaTwwP3VuZGVmaW5lZDppKSk7XG4vKiBpIDwgMCBtZWFucyB0aGVyZSB3YXMgbm8gaWZhY2UgaW5jbHVkZWQuKi9cbmNvbnN0IGlmYWNlPWk8MD91bmRlZmluZWQ6c3RyaW5nRW5jb2Rpbmcuc2xpY2UoaSsxKTtcbnJldHVybiBkZWNvZGVTbG90Q29tbW9uKHtpZmFjZSxpbmRleH0pO1xuIH07XG4gfTtcbmNvbnN0IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzKCckJyk7XG5jb25zdCBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyYnKTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyxkZWNvZGVSZWN1cik9PntcbmNvbnN0eycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdEVyckRhdGF9PWVuY29kaW5nO1xuIWhhc093blByb3BlcnR5T2YocmVzdEVyckRhdGEsJ21lc3NhZ2UnKXx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgZXJyb3IgcHJvcGVydHkgJHtxKCdtZXNzYWdlJyl9YDtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbih7bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX0sZGVjb2RlUmVjdXIpO1xuIH07XG5cbmNvbnN0IHJldml2ZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZUZyb21TbWFsbGNhcHMoe1xuLyogQHRzLWlnbm9yZSBYWFggU21hbGxDYXBzRW5jb2RpbmcqL1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcyxcbi8qIEB0cy1pZ25vcmUgWFhYIFNtYWxsQ2Fwc0VuY29kaW5nKi9cbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc30pO1xuIH07XG5cbi8qKlxuICogQHR5cGUge0Zyb21DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCBmcm9tQ2FwRGF0YT0oZGF0YSk9PntcbmNvbnN0e2JvZHksc2xvdHN9PWRhdGE7XG50eXBlb2YgYm9keT09PSdzdHJpbmcnfHxcbkZhaWwgYHVuc2VyaWFsaXplKCkgZ2l2ZW4gbm9uLWNhcGRhdGEgKC5ib2R5IGlzICR7Ym9keX0sIG5vdCBzdHJpbmcpYDtcbmlzQXJyYXkoZGF0YS5zbG90cyl8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLnNsb3RzIGFyZSBub3QgQXJyYXkpYDtcbmNvbnN0e3Jldml2ZUZyb21DYXBEYXRhLHJldml2ZUZyb21TbWFsbGNhcHN9PW1ha2VGdWxsUmV2aXZlKHNsb3RzKTtcbmxldCByZXN1bHQ7XG4vKiBKU09OIGNhbm5vdCBiZWdpbiB3aXRoIGEgJyMnLCBzbyB0aGlzIGlzIGFuIHVuYW1iaWd1b3VzIHNpZ25hbC4qL1xuaWYoYm9keS5jaGFyQXQoMCk9PT0nIycpe1xuY29uc3Qgc21hbGxjYXBzQm9keT1ib2R5LnNsaWNlKDEpO1xuY29uc3QgZW5jb2Rpbmc9aGFyZGVuKEpTT04ucGFyc2Uoc21hbGxjYXBzQm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tU21hbGxjYXBzKGVuY29kaW5nKSk7XG4gfWVsc2V7XG5jb25zdCByYXdUcmVlPWhhcmRlbihKU09OLnBhcnNlKGJvZHkpKTtcbnJlc3VsdD1oYXJkZW4ocmV2aXZlRnJvbUNhcERhdGEocmF3VHJlZSkpO1xuIH1cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzcqL1xuLyogd2hpY2ggc2hvdWxkIGJlIGNvbnNpZGVyZWQgZml4ZWQgb25jZSB3ZSd2ZSBjb21wbGV0ZWQgdGhlIHN3aXRjaCovXG4vKiB0byBzbWFsbGNhcHMuKi9cbmFzc2VydFBhc3NhYmxlKHJlc3VsdCk7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc2FibGVDYXB9ICovcmVzdWx0KTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtcbnRvQ2FwRGF0YSxcbmZyb21DYXBEYXRhLFxuXG4vKiBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkqL1xuLyoqIEBkZXByZWNhdGVkIHVzZSB0b0NhcERhdGEgKi9cbnNlcmlhbGl6ZTp0b0NhcERhdGEsXG4vKiogQGRlcHJlY2F0ZWQgdXNlIGZyb21DYXBEYXRhICovXG51bnNlcmlhbGl6ZTpmcm9tQ2FwRGF0YX0pO1xuXG4gfTskaM2PX29uY2UubWFrZU1hcnNoYWwobWFrZU1hcnNoYWwpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZU1hcnNoYWwiOlsibWFrZU1hcnNoYWwiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZrtByttBAADbQQAAJQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyIsIi4vZW5jb2RlUGFzc2FibGUuanMiXSwiZXhwb3J0cyI6WyJGdWxsUmFua0NvdmVyIiwiYXNzZXJ0UmFua1NvcnRlZCIsImNvbXBhcmF0b3JNaXJyb3JJbWFnZSIsImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVSYW5rIiwiY292ZXJlZEVudHJpZXMiLCJnZXRJbmRleENvdmVyIiwiZ2V0UGFzc1N0eWxlQ292ZXIiLCJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaXNSYW5rU29ydGVkIiwibWFrZUNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsInNvcnRCeVJhbmsiLCJ0cml2aWFsQ29tcGFyYXRvciIsInVuaW9uUmFua0NvdmVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBnZXRUYWcscGFzc1N0eWxlT2YsbmFtZUZvclBhc3NhYmxlU3ltYm9sLEZhaWwscSxwYXNzU3R5bGVQcmVmaXhlcyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVBhc3NhYmxlLmpzXCIsIFtbXCJwYXNzU3R5bGVQcmVmaXhlc1wiLCBbJGjNj19hID0+IChwYXNzU3R5bGVQcmVmaXhlcyA9ICRozY9fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjNj19hID0+IChyZWNvcmROYW1lcyA9ICRozY9fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRozY9fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUGFzc1N0eWxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJ1xuICogQGltcG9ydCB7RnVsbENvbXBhcmUsIFBhcnRpYWxDb21wYXJlLCBQYXJ0aWFsQ29tcGFyaXNvbiwgUmFua0NvbXBhcmUsIFJhbmtDb3Zlcn0gZnJvbSAnLi90eXBlcy5qcydcbiAqL1xuXG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLHNldFByb3RvdHlwZU9mLGlzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmFua0NvbXBhcmF0b3JLaXRcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGFudGlDb21wYXJhdG9yXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGdWxsQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtbbnVtYmVyLCBudW1iZXJdfSBJbmRleENvdmVyXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBlcXVhbGl0eSBjb21wYXJpc29uIHVzZWQgYnkgSmF2YVNjcmlwdCdzIE1hcCBhbmQgU2V0XG4gKiBhYnN0cmFjdGlvbnMsIHdoZXJlIE5hTiBpcyB0aGUgc2FtZSBhcyBOYU4gYW5kIC0wIGlzIHRoZSBzYW1lIGFzXG4gKiAwLiBNYXJzaGFsIHNlcmlhbGl6ZXMgLTAgYXMgemVybywgc28gdGhlIHNlbWFudGljcyBvZiBvdXIgZGlzdHJpYnV0ZWRcbiAqIG9iamVjdCBzeXN0ZW0gZG9lcyBub3QgZGlzdGluZ3Vpc2ggMCBmcm9tIC0wLlxuICpcbiAqIGBzYW1lVmFsdWVaZXJvYCBpcyB0aGUgRWNtYVNjcmlwdCBzcGVjIG5hbWUgZm9yIHRoaXMgZXF1YWxpdHkgY29tcGFyaXNvbixcbiAqIGJ1dCBUT0RPIHdlIG5lZWQgYSBiZXR0ZXIgbmFtZSBmb3IgdGhlIEFQSS5cbiAqXG4gKiBAcGFyYW0ge2FueX0geFxuICogQHBhcmFtIHthbnl9IHlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzYW1lVmFsdWVaZXJvPSh4LHkpPT54PT09eXx8aXMoeCx5KTtcblxuY29uc3QgICAgICAgIHRyaXZpYWxDb21wYXJhdG9yPShsZWZ0LHJpZ2h0KT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnksIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMqL1xubGVmdDxyaWdodD8tMTpsZWZ0PT09cmlnaHQ/MDoxO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8UGFzc1N0eWxlLCB7IGluZGV4OiBudW1iZXIsIGNvdmVyOiBSYW5rQ292ZXIgfT59IFBhc3NTdHlsZVJhbmtzUmVjb3JkXG4gKi8kaM2PX29uY2UudHJpdmlhbENvbXBhcmF0b3IodHJpdmlhbENvbXBhcmF0b3IpO1xuXG5jb25zdCBwYXNzU3R5bGVSYW5rcz0vKiogQHR5cGUge1Bhc3NTdHlsZVJhbmtzUmVjb3JkfSAqL1xuZnJvbUVudHJpZXMoXG5lbnRyaWVzKHBhc3NTdHlsZVByZWZpeGVzKVxuLyogU29ydCBlbnRyaWVzIGJ5IGFzY2VuZGluZyBwcmVmaXguKi8uXG5zb3J0KChbX2xlZnRTdHlsZSxsZWZ0UHJlZml4ZXNdLFtfcmlnaHRTdHlsZSxyaWdodFByZWZpeGVzXSk9PntcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihsZWZ0UHJlZml4ZXMscmlnaHRQcmVmaXhlcyk7XG4gfSkuXG5tYXAoKFtwYXNzU3R5bGUscHJlZml4ZXNdLGluZGV4KT0+e1xuLyogQ292ZXIgYWxsIHN0cmluZ3MgdGhhdCBzdGFydCB3aXRoIGFueSBjaGFyYWN0ZXIgaW4gYHByZWZpeGVzYCwqL1xuLyogdmVyaWZ5aW5nIHRoYXQgaXQgaXMgc29ydGVkIHNvIHRoYXQgaXMqL1xuLyogYWxsIHMgc3VjaCB0aGF0IHByZWZpeGVzLmF0KDApIOKJpCBzIDwgc3VjY2Vzc29yKHByZWZpeGVzLmF0KC0xKSkuKi9cbnByZWZpeGVzPT09Wy4uLnByZWZpeGVzXS5zb3J0KCkuam9pbignJyl8fFxuRmFpbCBgdW5zb3J0ZWQgcHJlZml4ZXMgZm9yIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7cShwcmVmaXhlcyl9YDtcbmNvbnN0IGNvdmVyPVtcbnByZWZpeGVzLmNoYXJBdCgwKSxcblN0cmluZy5mcm9tQ2hhckNvZGUocHJlZml4ZXMuY2hhckNvZGVBdChwcmVmaXhlcy5sZW5ndGgtMSkrMSldO1xuXG5yZXR1cm5bcGFzc1N0eWxlLHtpbmRleCxjb3Zlcn1dO1xuIH0pKTtcblxuXG5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVSYW5rcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVSYW5rcyk7XG5cbi8qKlxuICogQXNzb2NpYXRlIHdpdGggZWFjaCBwYXNzU3R5bGUgYSBSYW5rQ292ZXIgdGhhdCBtYXkgYmUgYW4gb3ZlcmVzdGltYXRlLFxuICogYW5kIHdob3NlIHJlc3VsdHMgdGhlcmVmb3JlIG5lZWQgdG8gYmUgZmlsdGVyZWQgZG93bi4gRm9yIGV4YW1wbGUsIGJlY2F1c2VcbiAqIHRoZXJlIGlzIG5vdCBhIHNtYWxsZXN0IG9yIGJpZ2dlc3QgYmlnaW50LCBib3VuZCBpdCBieSBgTmFOYCAodGhlIGxhc3QgcGxhY2VcbiAqIG51bWJlcikgYW5kIGAnJ2AgKHRoZSBlbXB0eSBzdHJpbmcsIHdoaWNoIGlzIHRoZSBmaXJzdCBwbGFjZSBzdHJpbmcpLiBUaHVzLFxuICogYSByYW5nZSBxdWVyeSB1c2luZyB0aGlzIHJhbmdlIG1heSBpbmNsdWRlIHRoZXNlIHZhbHVlcywgd2hpY2ggd291bGQgdGhlblxuICogbmVlZCB0byBiZSBmaWx0ZXJlZCBvdXQuXG4gKlxuICogQHBhcmFtIHtQYXNzU3R5bGV9IHBhc3NTdHlsZVxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldFBhc3NTdHlsZUNvdmVyPShwYXNzU3R5bGUpPT5wYXNzU3R5bGVSYW5rc1twYXNzU3R5bGVdLmNvdmVyOyRozY9fb25jZS5nZXRQYXNzU3R5bGVDb3ZlcihnZXRQYXNzU3R5bGVDb3Zlcik7XG5oYXJkZW4oZ2V0UGFzc1N0eWxlQ292ZXIpO1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPFJhbmtDb21wYXJlLFdlYWtTZXQ8UGFzc2FibGVbXT4+fVxuICovXG5jb25zdCBtZW1vT2ZTb3J0ZWQ9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxSYW5rQ29tcGFyZT59XG4gKi9cbmNvbnN0IGNvbXBhcmF0b3JNaXJyb3JJbWFnZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhcnRpYWxDb21wYXJlfSBbY29tcGFyZVJlbW90YWJsZXNdXG4gKiBBIGNvbXBhcmF0b3IgZm9yIGFzc2lnbmluZyBhbiBpbnRlcm5hbCBvcmRlciB0byByZW1vdGFibGVzLlxuICogSXQgZGVmYXVsdHMgdG8gYSBmdW5jdGlvbiB0aGF0IGFsd2F5cyByZXR1cm5zIGBOYU5gLCBtZWFuaW5nIHRoYXQgYWxsXG4gKiByZW1vdGFibGVzIGFyZSBpbmNvbXBhcmFibGUgYW5kIHNob3VsZCB0aWUgZm9yIHRoZSBzYW1lIHJhbmsgYnlcbiAqIHNob3J0LWNpcmN1aXRpbmcgd2l0aG91dCBmdXJ0aGVyIHJlZmluZW1lbnQgKGUuZy4sIG5vdCBvbmx5IGFyZSBgcjFgIGFuZCBgcjJgXG4gKiB0aWVkLCBidXQgc28gYXJlIGBbcjEsIDBdYCBhbmQgYFtyMiwgXCJ4XCJdYCkuXG4gKiBAcmV0dXJucyB7UmFua0NvbXBhcmF0b3JLaXR9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29tcGFyYXRvcktpdD0oY29tcGFyZVJlbW90YWJsZXM9KF94LF95KT0+TmFOKT0+e1xuLyoqIEB0eXBlIHtQYXJ0aWFsQ29tcGFyZX0gKi9cbmNvbnN0IGNvbXBhcmF0b3I9KGxlZnQscmlnaHQpPT57XG5pZihzYW1lVmFsdWVaZXJvKGxlZnQscmlnaHQpKXtcbnJldHVybiAwO1xuIH1cbmNvbnN0IGxlZnRTdHlsZT1wYXNzU3R5bGVPZihsZWZ0KTtcbmNvbnN0IHJpZ2h0U3R5bGU9cGFzc1N0eWxlT2YocmlnaHQpO1xuaWYobGVmdFN0eWxlIT09cmlnaHRTdHlsZSl7XG5yZXR1cm4gdHJpdmlhbENvbXBhcmF0b3IoXG5wYXNzU3R5bGVSYW5rc1tsZWZ0U3R5bGVdLmluZGV4LFxucGFzc1N0eWxlUmFua3NbcmlnaHRTdHlsZV0uaW5kZXgpO1xuXG4gfVxuLyogZXNsaW50LWRpc2FibGUgQGVuZG8vcmVzdHJpY3QtY29tcGFyaXNvbi1vcGVyYW5kcyAtLVxuICogV2Uga25vdyBgbGVmdGAgYW5kIGByaWdodGAgYXJlIGNvbXBhcmFibGUuXG4gKi9cbnN3aXRjaChsZWZ0U3R5bGUpe1xuY2FzZSdyZW1vdGFibGUnOntcbnJldHVybiBjb21wYXJlUmVtb3RhYmxlcyhsZWZ0LHJpZ2h0KTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ251bGwnOlxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbi8qIEZvciBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIGFsbCBtZW1iZXJzIG9mIHRoYXQgcGFzc1N0eWxlIGFyZSB0aWVkKi9cbi8qIGZvciB0aGUgc2FtZSByYW5rLiovXG5yZXR1cm4gMDtcbiB9XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOntcbi8qIFdpdGhpbiBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIHRoZSByYW5rIG9yZGVyaW5nIGFncmVlcyB3aXRoKi9cbi8qIEphdmFTY3JpcHQncyByZWxhdGlvbmFsIG9wZXJhdG9ycyBgPGAgYW5kIGA+YC4qL1xuaWYobGVmdDxyaWdodCl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbmFzc2VydChsZWZ0PnJpZ2h0KTtcbnJldHVybiAxO1xuIH1cbiB9XG5jYXNlJ3N5bWJvbCc6e1xucmV0dXJuIGNvbXBhcmF0b3IoXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wobGVmdCksXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wocmlnaHQpKTtcblxuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBgTmFOYCdzIHJhbmsgaXMgYWZ0ZXIgYWxsIG90aGVyIG51bWJlcnMuKi9cbmlmKE51bWJlci5pc05hTihsZWZ0KSl7XG5hc3NlcnQoIU51bWJlci5pc05hTihyaWdodCkpO1xucmV0dXJuIDE7XG4gfWVsc2UgaWYoTnVtYmVyLmlzTmFOKHJpZ2h0KSl7XG5yZXR1cm4tMTtcbiB9XG4vKiBUaGUgcmFuayBvcmRlcmluZyBvZiBub24tTmFOIG51bWJlcnMgYWdyZWVzIHdpdGggSmF2YVNjcmlwdCdzKi9cbi8qIHJlbGF0aW9uYWwgb3BlcmF0b3JzICc8JyBhbmQgJz4nLiovXG5pZihsZWZ0PHJpZ2h0KXtcbnJldHVybi0xO1xuIH1lbHNle1xuYXNzZXJ0KGxlZnQ+cmlnaHQpO1xucmV0dXJuIDE7XG4gfVxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBpbnZlcnNlIHNvcnRlZCBvcmRlciBvZiBwcm9wZXJ0eSBuYW1lcywgdGhlbiovXG4vKiBsZXhpY29ncmFwaGljIGJ5IGNvcnJlc3BvbmRpbmcgdmFsdWVzIGluIHRoYXQgc2FtZSBpbnZlcnNlKi9cbi8qIG9yZGVyIG9mIHRoZWlyIHByb3BlcnR5IG5hbWVzLiBDb21wYXJpbmcgbmFtZXMgYnkgdGhlbXNlbHZlcyBmaXJzdCwqL1xuLyogYWxsIHJlY29yZHMgd2l0aCB0aGUgZXhhY3Qgc2FtZSBzZXQgb2YgcHJvcGVydHkgbmFtZXMgc29ydCBuZXh0IHRvKi9cbi8qIGVhY2ggb3RoZXIgaW4gYSByYW5rLXNvcnQgb2YgY29weVJlY29yZHMuKi9cblxuLyogVGhlIGNvcHlSZWNvcmQgaW52YXJpYW50cyBlbmZvcmNlZCBieSBwYXNzU3R5bGVPZiBlbnN1cmUgdGhhdCovXG4vKiBhbGwgdGhlIHByb3BlcnR5IG5hbWVzIGFyZSBzdHJpbmdzLiBXZSBuZWVkIHRoZSByZXZlcnNlIHNvcnRlZCBvcmRlciovXG4vKiBvZiB0aGVzZSBuYW1lcywgd2hpY2ggd2UgdGhlbiBjb21wYXJlIGxleGljb2dyYXBoaWNhbGx5LiBUaGlzIGVuc3VyZXMqL1xuLyogdGhhdCBpZiB0aGUgbmFtZXMgb2YgcmVjb3JkIFggYXJlIGEgc3Vic2V0IG9mIHRoZSBuYW1lcyBvZiByZWNvcmQgWSwqL1xuLyogdGhlbiByZWNvcmQgWCB3aWxsIGhhdmUgYW4gZWFybGllciByYW5rIGFuZCBzb3J0IHRvIHRoZSBsZWZ0IG9mIFkuKi9cbmNvbnN0IGxlZnROYW1lcz1yZWNvcmROYW1lcyhsZWZ0KTtcbmNvbnN0IHJpZ2h0TmFtZXM9cmVjb3JkTmFtZXMocmlnaHQpO1xuXG5jb25zdCByZXN1bHQ9Y29tcGFyYXRvcihsZWZ0TmFtZXMscmlnaHROYW1lcyk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuY29uc3QgbGVmdFZhbHVlcz1yZWNvcmRWYWx1ZXMobGVmdCxsZWZ0TmFtZXMpO1xuY29uc3QgcmlnaHRWYWx1ZXM9cmVjb3JkVmFsdWVzKHJpZ2h0LHJpZ2h0TmFtZXMpO1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdFZhbHVlcyxyaWdodFZhbHVlcyk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMqL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnRbaV0scmlnaHRbaV0pO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG4vKiBJZiBhbGwgbWF0Y2hpbmcgZWxlbWVudHMgd2VyZSB0aWVkLCB0aGVuIGFjY29yZGluZyB0byB0aGVpciBsZW5ndGhzLiovXG4vKiBJZiBhcnJheSBYIGlzIGEgcHJlZml4IG9mIGFycmF5IFksIHRoZW4gWCBoYXMgYW4gZWFybGllciByYW5rIHRoYW4gWS4qL1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBgW1N5bWJvbC50b1N0cmluZ1RhZ11gIHRoZW4gYC5wYXlsb2FkYC4qL1xuY29uc3QgbGFiZWxDb21wPWNvbXBhcmF0b3IoZ2V0VGFnKGxlZnQpLGdldFRhZyhyaWdodCkpO1xuaWYobGFiZWxDb21wIT09MCl7XG5yZXR1cm4gbGFiZWxDb21wO1xuIH1cbnJldHVybiBjb21wYXJhdG9yKGxlZnQucGF5bG9hZCxyaWdodC5wYXlsb2FkKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBwYXNzU3R5bGU6ICR7cShsZWZ0U3R5bGUpfWA7XG4gfX1cblxuLyogZXNsaW50LWVuYWJsZSAqL1xuIH07XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBvdXRlckNvbXBhcmF0b3I9KHgseSk9PlxuLyogV2hlbiB0aGUgaW5uZXIgY29tcGFyYXRvciByZXR1cm5zIE5hTiB0byBpbmRpY2F0ZSBpbmNvbXBhcmFiaWxpdHksKi9cbi8qIHJlcGxhY2UgdGhhdCB3aXRoIDAgdG8gaW5kaWNhdGUgYSB0aWUuKi9cbi8qKiBAdHlwZSB7RXhjbHVkZTxQYXJ0aWFsQ29tcGFyaXNvbiwgTmFOPn0gKi9jb21wYXJhdG9yKHgseSl8fDA7XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBhbnRpQ29tcGFyYXRvcj0oeCx5KT0+b3V0ZXJDb21wYXJhdG9yKHkseCk7XG5cbm1lbW9PZlNvcnRlZC5zZXQob3V0ZXJDb21wYXJhdG9yLG5ldyBXZWFrU2V0KCkpO1xubWVtb09mU29ydGVkLnNldChhbnRpQ29tcGFyYXRvcixuZXcgV2Vha1NldCgpKTtcbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuc2V0KG91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcik7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChhbnRpQ29tcGFyYXRvcixvdXRlckNvbXBhcmF0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtjb21wYXJhdG9yOm91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcn0pO1xuIH07XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEByZXR1cm5zIHtSYW5rQ29tcGFyZT19XG4gKi8kaM2PX29uY2UubWFrZUNvbXBhcmF0b3JLaXQobWFrZUNvbXBhcmF0b3JLaXQpO1xuY29uc3QgICAgICAgIGNvbXBhcmF0b3JNaXJyb3JJbWFnZT0oY29tcGFyYXRvcik9PlxuY29tcGFyYXRvck1pcnJvckltYWdlcy5nZXQoY29tcGFyYXRvcik7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjNj19vbmNlLmNvbXBhcmF0b3JNaXJyb3JJbWFnZShjb21wYXJhdG9yTWlycm9ySW1hZ2UpO1xuY29uc3QgICAgICAgIGlzUmFua1NvcnRlZD0ocGFzc2FibGVzLGNvbXBhcmUpPT57XG5jb25zdCBzdWJNZW1vT2ZTb3J0ZWQ9bWVtb09mU29ydGVkLmdldChjb21wYXJlKTtcbmFzc2VydChzdWJNZW1vT2ZTb3J0ZWQhPT11bmRlZmluZWQpO1xuaWYoc3ViTWVtb09mU29ydGVkLmhhcyhwYXNzYWJsZXMpKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydChwYXNzU3R5bGVPZihwYXNzYWJsZXMpPT09J2NvcHlBcnJheScpO1xuZm9yKGxldCBpPTE7aTxwYXNzYWJsZXMubGVuZ3RoO2krPTEpe1xuaWYoY29tcGFyZShwYXNzYWJsZXNbaS0xXSxwYXNzYWJsZXNbaV0pPj0xKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuc3ViTWVtb09mU29ydGVkLmFkZChwYXNzYWJsZXMpO1xucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNSYW5rU29ydGVkKGlzUmFua1NvcnRlZCk7XG5oYXJkZW4oaXNSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UmFua1NvcnRlZD0oc29ydGVkLGNvbXBhcmUpPT5cbmlzUmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSl8fFxuLyogVE9ETyBhc3NlcnQgb24gYnVnIGNvdWxkIGxlYWQgdG8gaW5maW5pdGUgcmVjdXJzaW9uLiBGaXguKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5GYWlsIGBNdXN0IGJlIHJhbmsgc29ydGVkOiAke3NvcnRlZH0gdnMgJHtzb3J0QnlSYW5rKHNvcnRlZCxjb21wYXJlKX1gOyRozY9fb25jZS5hc3NlcnRSYW5rU29ydGVkKGFzc2VydFJhbmtTb3J0ZWQpO1xuaGFyZGVuKGFzc2VydFJhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHBhc3NhYmxlc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHNvcnRCeVJhbms9KHBhc3NhYmxlcyxjb21wYXJlKT0+e1xuaWYoQXJyYXkuaXNBcnJheShwYXNzYWJsZXMpKXtcbmhhcmRlbihwYXNzYWJsZXMpO1xuLyogQ2FsbGluZyBpc1JhbmtTb3J0ZWQgZ2l2ZXMgaXQgYSBjaGFuY2UgdG8gZ2V0IG1lbW9pemVkIGZvciovXG4vKiB0aGlzIGBjb21wYXJlYCBmdW5jdGlvbiBldmVuIGlmIGl0IHdhcyBhbHJlYWR5IG1lbW9pemVkIGZvciBhIGRpZmZlcmVudCovXG4vKiBgY29tcGFyZWAgZnVuY3Rpb24uKi9cbmlmKGlzUmFua1NvcnRlZChwYXNzYWJsZXMsY29tcGFyZSkpe1xucmV0dXJuIHBhc3NhYmxlcztcbiB9XG4gfVxuY29uc3QgdW5zb3J0ZWQ9Wy4uLnBhc3NhYmxlc107XG51bnNvcnRlZC5mb3JFYWNoKGhhcmRlbik7XG5jb25zdCBzb3J0ZWQ9dW5zb3J0ZWQuc29ydChjb21wYXJlKTtcbi8qIEZvciByZXZlcnNlIGNvbXBhcmlzb24sIG1vdmUgYHVuZGVmaW5lZGAgdmFsdWVzIGZyb20gdGhlIGVuZCB0byB0aGUgc3RhcnQuKi9cbi8qIE5vdGUgdGhhdCBwYXNzU3R5bGVQcmVmaXhlcyAoQHNlZSB7QGxpbmsgLi9lbmNvZGVQYXNzYWJsZS5qc30pIE1VU1QgTk9UKi9cbi8qIHNvcnQgYW55IGNhdGVnb3J5IGFmdGVyIGB1bmRlZmluZWRgLiovXG5pZihjb21wYXJlKHRydWUsdW5kZWZpbmVkKT4wKXtcbmxldCBpPXNvcnRlZC5sZW5ndGgtMTtcbndoaWxlKGk+PTAmJnNvcnRlZFtpXT09PXVuZGVmaW5lZClpLT0xO1xuY29uc3Qgbj1zb3J0ZWQubGVuZ3RoLWktMTtcbmlmKG4+MCYmbjxzb3J0ZWQubGVuZ3RoKXtcbnNvcnRlZC5jb3B5V2l0aGluKG4sMCk7XG5zb3J0ZWQuZmlsbCgvKiogQHR5cGUge1R9ICovdW5kZWZpbmVkLDAsbik7XG4gfVxuIH1cbmhhcmRlbihzb3J0ZWQpO1xuY29uc3Qgc3ViTWVtb09mU29ydGVkPW1lbW9PZlNvcnRlZC5nZXQoY29tcGFyZSk7XG5hc3NlcnQoc3ViTWVtb09mU29ydGVkIT09dW5kZWZpbmVkKTtcbnN1Yk1lbW9PZlNvcnRlZC5hZGQoc29ydGVkKTtcbnJldHVybiBzb3J0ZWQ7XG4gfTskaM2PX29uY2Uuc29ydEJ5UmFuayhzb3J0QnlSYW5rKTtcbmhhcmRlbihzb3J0QnlSYW5rKTtcblxuLyoqXG4gKiBTZWVcbiAqIGh0dHBzOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0JpbmFyeV9zZWFyY2hfYWxnb3JpdGhtI1Byb2NlZHVyZV9mb3JfZmluZGluZ190aGVfbGVmdG1vc3RfZWxlbWVudFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBrZXlcbiAqIEBwYXJhbSB7KFwibGVmdE1vc3RcIiB8IFwicmlnaHRNb3N0XCIpPX0gYmlhc1xuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmFua1NlYXJjaD0oc29ydGVkLGNvbXBhcmUsa2V5LGJpYXM9J2xlZnRNb3N0Jyk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xubGV0IGxlZnQ9MDtcbmxldCByaWdodD1zb3J0ZWQubGVuZ3RoO1xud2hpbGUobGVmdDxyaWdodCl7XG5jb25zdCBtPU1hdGguZmxvb3IoKGxlZnQrcmlnaHQpLzIpO1xuY29uc3QgY29tcD1jb21wYXJlKHNvcnRlZFttXSxrZXkpO1xuaWYoY29tcDw9LTF8fGNvbXA9PT0wJiZiaWFzPT09J3JpZ2h0TW9zdCcpe1xubGVmdD1tKzE7XG4gfWVsc2V7XG5hc3NlcnQoY29tcD49MXx8Y29tcD09PTAmJmJpYXM9PT0nbGVmdE1vc3QnKTtcbnJpZ2h0PW07XG4gfVxuIH1cbnJldHVybiBiaWFzPT09J2xlZnRNb3N0Jz9sZWZ0OnJpZ2h0LTE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IHJhbmtDb3ZlclxuICogQHJldHVybnMge0luZGV4Q292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbmRleENvdmVyPShzb3J0ZWQsY29tcGFyZSxbbGVmdEtleSxyaWdodEtleV0pPT57XG5hc3NlcnRSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKTtcbmNvbnN0IGxlZnRJbmRleD1yYW5rU2VhcmNoKHNvcnRlZCxjb21wYXJlLGxlZnRLZXksJ2xlZnRNb3N0Jyk7XG5jb25zdCByaWdodEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUscmlnaHRLZXksJ3JpZ2h0TW9zdCcpO1xucmV0dXJuW2xlZnRJbmRleCxyaWdodEluZGV4XTtcbiB9OyRozY9fb25jZS5nZXRJbmRleENvdmVyKGdldEluZGV4Q292ZXIpO1xuaGFyZGVuKGdldEluZGV4Q292ZXIpO1xuXG4vKiogQHR5cGUge1JhbmtDb3Zlcn0gKi9cbmNvbnN0ICAgICAgICBGdWxsUmFua0NvdmVyPWhhcmRlbihbJycsJ3snXSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7SW5kZXhDb3Zlcn0gaW5kZXhDb3ZlclxuICogQHJldHVybnMge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59XG4gKi8kaM2PX29uY2UuRnVsbFJhbmtDb3ZlcihGdWxsUmFua0NvdmVyKTtcbmNvbnN0ICAgICAgICBjb3ZlcmVkRW50cmllcz0oc29ydGVkLFtsZWZ0SW5kZXgscmlnaHRJbmRleF0pPT57XG4vKiogQHR5cGUge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59ICovXG5jb25zdCBpdGVyYWJsZT1oYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmxldCBpPWxlZnRJbmRleDtcbnJldHVybiBoYXJkZW4oe1xubmV4dDooKT0+e1xuaWYoaTw9cmlnaHRJbmRleCl7XG5jb25zdCBlbGVtZW50PXNvcnRlZFtpXTtcbmkrPTE7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTpbaSxlbGVtZW50XSxkb25lOmZhbHNlfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTp1bmRlZmluZWQsZG9uZTp0cnVlfSk7XG4gfVxuIH19KTtcblxuIH19KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjNj19vbmNlLmNvdmVyZWRFbnRyaWVzKGNvdmVyZWRFbnRyaWVzKTtcbmhhcmRlbihjb3ZlcmVkRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtYXhSYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKT49MD9hOmI7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtaW5SYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKTw9MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgdW5pb25SYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCB1bmlvblJhbmtDb3ZlclBhaXI9KFtsZWZ0QSxyaWdodEFdLFtsZWZ0QixyaWdodEJdKT0+W1xubWluUmFuayhjb21wYXJlLGxlZnRBLGxlZnRCKSxcbm1heFJhbmsoY29tcGFyZSxyaWdodEEscmlnaHRCKV07XG5cbnJldHVybiBjb3ZlcnMucmVkdWNlKHVuaW9uUmFua0NvdmVyUGFpcixbJ3snLCcnXSk7XG4gfTskaM2PX29uY2UudW5pb25SYW5rQ292ZXJzKHVuaW9uUmFua0NvdmVycyk7XG5oYXJkZW4odW5pb25SYW5rQ292ZXJzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpbnRlcnNlY3RSYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCBpbnRlcnNlY3RSYW5rQ292ZXJQYWlyPShbbGVmdEEscmlnaHRBXSxbbGVmdEIscmlnaHRCXSk9Pltcbm1heFJhbmsoY29tcGFyZSxsZWZ0QSxsZWZ0QiksXG5taW5SYW5rKGNvbXBhcmUscmlnaHRBLHJpZ2h0QildO1xuXG5yZXR1cm4gY292ZXJzLnJlZHVjZShpbnRlcnNlY3RSYW5rQ292ZXJQYWlyLFsnJywneyddKTtcbiB9OyRozY9fb25jZS5pbnRlcnNlY3RSYW5rQ292ZXJzKGludGVyc2VjdFJhbmtDb3ZlcnMpO1xuXG5jb25zdCAgICAgICB7Y29tcGFyYXRvcjpjb21wYXJlUmFuayxhbnRpQ29tcGFyYXRvcjpjb21wYXJlQW50aVJhbmt9PVxubWFrZUNvbXBhcmF0b3JLaXQoKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjb21wYXJhdG9yIGtpdCBpbiB3aGljaCByZW1vdGFibGVzIGFyZSBmdWxseSBvcmRlcmVkXG4gKiBieSB0aGUgb3JkZXIgaW4gd2hpY2ggdGhleSBhcmUgZmlyc3Qgc2VlbiBieSAqdGhpcyogY29tcGFyYXRvciBraXQuXG4gKiBCRVdBUkU6IFRoaXMgaXMgb2JzZXJ2YWJsZSBtdXRhYmxlIHN0YXRlLCBzbyBzdWNoIGEgY29tcGFyYXRvciBraXRcbiAqIHNob3VsZCBuZXZlciBiZSBzaGFyZWQgYW1vbmcgc3Vic3lzdGVtcyB0aGF0IHNob3VsZCBub3QgYmUgYWJsZVxuICogdG8gY29tbXVuaWNhdGUuXG4gKlxuICogTm90ZSB0aGF0IHRoaXMgb3JkZXIgZG9lcyBub3QgbWVldCB0aGUgcmVxdWlyZW1lbnRzIGZvciBzdG9yZVxuICogb3JkZXJpbmcsIHNpbmNlIGl0IGhhcyBubyBtZW1vcnkgb2YgZGVsZXRlZCBrZXlzLlxuICpcbiAqIFRoZXNlIGZ1bGwgb3JkZXIgY29tcGFyYXRvciBraXQgaXMgc3RyaWN0bHkgbW9yZSBwcmVjaXNlIHRoYXQgdGhlXG4gKiByYW5rIG9yZGVyIGNvbXBhcmF0b3Iga2l0cyBhYm92ZS4gQXMgYSByZXN1bHQsIGFueSBhcnJheSB3aGljaCBpc1xuICogc29ydGVkIGJ5IHN1Y2ggYSBmdWxsIG9yZGVyIHdpbGwgcGFzcyB0aGUgaXNSYW5rU29ydGVkIHRlc3Qgd2l0aFxuICogYSBjb3JyZXNwb25kaW5nIHJhbmsgb3JkZXIuXG4gKlxuICogQW4gYXJyYXkgd2hpY2ggaXMgc29ydGVkIGJ5IGEgKmZyZXNoKiBmdWxsIG9yZGVyIGNvbXBhcmF0b3IsIGkuZS4sXG4gKiBvbmUgdGhhdCBoYXMgbm90IHlldCBzZWVuIGFueSByZW1vdGFibGVzLCB3aWxsIG9mIGNvdXJzZSByZW1haW5cbiAqIHNvcnRlZCBieSBhY2NvcmRpbmcgdG8gKnRoYXQqIGZ1bGwgb3JkZXIgY29tcGFyYXRvci4gQW4gYXJyYXkgKm9mXG4gKiBzY2FsYXJzKiBzb3J0ZWQgYnkgYSBmcmVzaCBmdWxsIG9yZGVyIHdpbGwgcmVtYWluIHNvcnRlZCBldmVuXG4gKiBhY2NvcmRpbmcgdG8gYSBuZXcgZnJlc2ggZnVsbCBvcmRlciBjb21wYXJhdG9yLCBzaW5jZSBpdCB3aWxsIHNlZVxuICogdGhlIHJlbW90YWJsZXMgaW4gdGhlIHNhbWUgb3JkZXIgYWdhaW4uIFVuZm9ydHVuYXRlbHksIHRoaXMgaXNcbiAqIG5vdCB0cnVlIG9mIGFycmF5cyBvZiBwYXNzYWJsZXMgaW4gZ2VuZXJhbC5cbiAqXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBsb25nTGl2ZWRcbiAqIEByZXR1cm5zIHtGdWxsQ29tcGFyYXRvcktpdH1cbiAqLyRozY9fb25jZS5jb21wYXJlUmFuayhjb21wYXJlUmFuayk7JGjNj19vbmNlLmNvbXBhcmVBbnRpUmFuayhjb21wYXJlQW50aVJhbmspO1xuY29uc3QgICAgICAgIG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0PShsb25nTGl2ZWQ9ZmFsc2UpPT57XG5sZXQgbnVtU2Vlbj0wO1xuLyogV2hlbiBkeW5hbWljYWxseSBjcmVhdGVkIHdpdGggc2hvcnQgbGlmZXRpbWVzICh0aGUgZGVmYXVsdCkgYSBXZWFrTWFwKi9cbi8qIHdvdWxkIHBlcmZvcm0gcG9vcmx5LCBhbmQgdGhlIGxlYWsgY3JlYXRlZCBieSBhIE1hcCBvbmx5IGxhc3RzIGFzIGxvbmcqL1xuLyogYXMgdGhlIE1hcC4qL1xuY29uc3QgTWFwQ29uc3RydWN0b3I9bG9uZ0xpdmVkP1dlYWtNYXA6TWFwO1xuY29uc3Qgc2Vlbj1uZXcgTWFwQ29uc3RydWN0b3IoKTtcbmNvbnN0IHRhZz0ocik9PntcbmlmKHNlZW4uaGFzKHIpKXtcbnJldHVybiBzZWVuLmdldChyKTtcbiB9XG5udW1TZWVuKz0xO1xuc2Vlbi5zZXQocixudW1TZWVuKTtcbnJldHVybiBudW1TZWVuO1xuIH07XG5jb25zdCBjb21wYXJlUmVtb3RhYmxlcz0oeCx5KT0+Y29tcGFyZVJhbmsodGFnKHgpLHRhZyh5KSk7XG5yZXR1cm4gbWFrZUNvbXBhcmF0b3JLaXQoY29tcGFyZVJlbW90YWJsZXMpO1xuIH07JGjNj19vbmNlLm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KTtcbmhhcmRlbihtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cml2aWFsQ29tcGFyYXRvciI6WyJ0cml2aWFsQ29tcGFyYXRvciJdLCJnZXRQYXNzU3R5bGVDb3ZlciI6WyJnZXRQYXNzU3R5bGVDb3ZlciJdLCJtYWtlQ29tcGFyYXRvcktpdCI6WyJtYWtlQ29tcGFyYXRvcktpdCJdLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiOlsiY29tcGFyYXRvck1pcnJvckltYWdlIl0sImlzUmFua1NvcnRlZCI6WyJpc1JhbmtTb3J0ZWQiXSwiYXNzZXJ0UmFua1NvcnRlZCI6WyJhc3NlcnRSYW5rU29ydGVkIl0sInNvcnRCeVJhbmsiOlsic29ydEJ5UmFuayJdLCJnZXRJbmRleENvdmVyIjpbImdldEluZGV4Q292ZXIiXSwiRnVsbFJhbmtDb3ZlciI6WyJGdWxsUmFua0NvdmVyIl0sImNvdmVyZWRFbnRyaWVzIjpbImNvdmVyZWRFbnRyaWVzIl0sInVuaW9uUmFua0NvdmVycyI6WyJ1bmlvblJhbmtDb3ZlcnMiXSwiaW50ZXJzZWN0UmFua0NvdmVycyI6WyJpbnRlcnNlY3RSYW5rQ292ZXJzIl0sImNvbXBhcmVSYW5rIjpbImNvbXBhcmVSYW5rIl0sImNvbXBhcmVBbnRpUmFuayI6WyJjb21wYXJlQW50aVJhbmsiXSwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiOlsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAai91qtYLAADWCwAAHgAAAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiTmF0IiwiaXNOYXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc05hdCwgJ25hbWUnLCB7dmFsdWU6IFwiaXNOYXRcIn0pOyRozY9fb25jZS5pc05hdChpc05hdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KE5hdCwgJ25hbWUnLCB7dmFsdWU6IFwiTmF0XCJ9KTskaM2PX29uY2UuTmF0KE5hdCk7ICAgLyogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuKi9cbi8qIENvcHlyaWdodCAoQykgMjAxOCBBZ29yaWMqL1xuLyoqL1xuLyogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTsqL1xuLyogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLiovXG4vKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQqL1xuLyoqL1xuLyogaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKi9cbi8qKi9cbi8qIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUqL1xuLyogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLCovXG4vKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4qL1xuLyogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCovXG4vKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4qL1xuXG4vKiBAdHMtY2hlY2sqL1xuXG4vKipcbiAqIElzIGBhbGxlZ2VkTnVtYCBhIG51bWJlciBpbiB0aGUgW2NvbnRpZ3VvdXMgcmFuZ2Ugb2YgZXhhY3RseSBhbmRcbiAqIHVuYW1iaWd1b3VzbHlcbiAqIHJlcHJlc2VudGFibGVdKGh0dHBzOi8vZXNkaXNjdXNzLm9yZy90b3BpYy9tb3JlLW51bWVyaWMtY29uc3RhbnRzLXBsZWFzZS1lc3BlY2lhbGx5LWVwc2lsb24jY29udGVudC0xNClcbiAqICBuYXR1cmFsIG51bWJlcnMgKG5vbi1uZWdhdGl2ZSBpbnRlZ2Vycyk/XG4gKlxuICogVG8gcXVhbGlmeSBgYWxsZWdlZE51bWAgbXVzdCBlaXRoZXIgYmUgYVxuICogbm9uLW5lZ2F0aXZlIGBiaWdpbnRgLCBvciBhIG5vbi1uZWdhdGl2ZSBgbnVtYmVyYCByZXByZXNlbnRpbmcgYW4gaW50ZWdlclxuICogd2l0aGluIHJhbmdlIG9mIFtpbnRlZ2VycyBzYWZlbHkgcmVwcmVzZW50YWJsZSBpblxuICogZmxvYXRpbmcgcG9pbnRdKGh0dHBzOi8vdGMzOS5lcy9lY21hMjYyLyNzZWMtbnVtYmVyLmlzc2FmZWludGVnZXIpLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gYWxsZWdlZE51bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmZ1bmN0aW9uIGlzTmF0KGFsbGVnZWROdW0pe1xuaWYodHlwZW9mIGFsbGVnZWROdW09PT0nYmlnaW50Jyl7XG5yZXR1cm4gYWxsZWdlZE51bT49MDtcbiB9XG5pZih0eXBlb2YgYWxsZWdlZE51bSE9PSdudW1iZXInKXtcbnJldHVybiBmYWxzZTtcbiB9XG5cbnJldHVybiBOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSYmYWxsZWdlZE51bT49MDtcbiB9XG5cbi8qKlxuICogSWYgYGFsbGVnZWROdW1iZXJgIHBhc3NlcyB0aGUgYGlzTmF0YCB0ZXN0LCB0aGVuIHJldHVybiBpdCBhcyBhIGJpZ2ludC5cbiAqIE90aGVyd2lzZSB0aHJvdyBhbiBhcHByb3ByaWF0ZSBlcnJvci5cbiAqXG4gKiBJZiBgYWxsZWdlZE51bWAgaXMgbmVpdGhlciBhIGJpZ2ludCBub3IgYSBudW1iZXIsIGBOYXRgIHRocm93cyBhIGBUeXBlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpZiBpdCBpcyBub3QgYSBbc2FmZWx5XG4gKiByZXByZXNlbnRhYmxlXShodHRwczovL2VzZGlzY3Vzcy5vcmcvdG9waWMvbW9yZS1udW1lcmljLWNvbnN0YW50cy1wbGVhc2UtZXNwZWNpYWxseS1lcHNpbG9uI2NvbnRlbnQtMTQpXG4gKiBub24tbmVnYXRpdmUgaW50ZWdlciwgYE5hdGAgdGhyb3dzIGEgYFJhbmdlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpdCBpcyBjb252ZXJ0ZWQgdG8gYSBiaWdpbnQgaWYgbmVjZXNzYXJ5IGFuZCByZXR1cm5lZC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGFsbGVnZWROdW1cbiAqIEByZXR1cm5zIHtiaWdpbnR9XG4gKi9cbmZ1bmN0aW9uIE5hdChhbGxlZ2VkTnVtKXtcbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J2JpZ2ludCcpe1xuaWYoYWxsZWdlZE51bTwwKXtcbnRocm93IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIGFsbGVnZWROdW07XG4gfVxuXG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdudW1iZXInKXtcbmlmKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSl7XG50aHJvdyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBpcyBub3QgYSBzYWZlIGludGVnZXJgKTtcbiB9XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gaXMgbmVnYXRpdmVgKTtcbiB9XG5yZXR1cm4gQmlnSW50KGFsbGVnZWROdW0pO1xuIH1cblxudGhyb3cgVHlwZUVycm9yKFxuIGAke2FsbGVnZWROdW19IGlzIGEgJHt0eXBlb2YgYWxsZWdlZE51bX0gYnV0IG11c3QgYmUgYSBiaWdpbnQgb3IgYSBudW1iZXJgKTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzTmF0IjpbImlzTmF0Il0sIk5hdCI6WyJOYXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoSmqvD8KAAA/CgAAIAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvZXJyb3IuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy9zdHJpbmcuanMiLCIuL3NyYy9wYXNzU3R5bGVPZi5qcyIsIi4vc3JjL21ha2VUYWdnZWQuanMiLCIuL3NyYy9tYWtlLWZhci5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiLCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkZhciIsImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSIsImFzc2VydFdlbGxGb3JtZWRTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiLCJpc09iamVjdCIsImlzT2JqZWN0IiwiaXNQYXNzYWJsZSIsImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtbXCIuL3NyYy9pdGVyLWhlbHBlcnMuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9lcnJvci5qc1wiLCBbXV0sW1wiLi9zcmMvcmVtb3RhYmxlLmpzXCIsIFtdXSxbXCIuL3NyYy9zeW1ib2wuanNcIiwgW11dLFtcIi4vc3JjL3N0cmluZy5qc1wiLCBbXV0sW1wiLi9zcmMvcGFzc1N0eWxlT2YuanNcIiwgW11dLFtcIi4vc3JjL21ha2VUYWdnZWQuanNcIiwgW11dLFtcIi4vc3JjL21ha2UtZmFyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlR3VhcmRzLmpzXCIsIFtdXSxbXCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvaXRlci1oZWxwZXJzLmpzIjpbWyJtYXBJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sWyJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIl1dLCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6W1siUEFTU19TVFlMRSIsIlBBU1NfU1RZTEUiXSxbImlzT2JqZWN0IiwiaXNPYmplY3QiXSxbImFzc2VydENoZWNrZXIiLCJhc3NlcnRDaGVja2VyIl0sWyJnZXRUYWciLCJnZXRUYWciXSxbImhhc093blByb3BlcnR5T2YiLCJoYXNPd25Qcm9wZXJ0eU9mIl1dLCIuL3NyYy9lcnJvci5qcyI6W1siZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImdldEVycm9yQ29uc3RydWN0b3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3N0cmluZy5qcyI6W1siaXNXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sWyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyJdLFsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRQYXNzYWJsZVN0cmluZyJdXSwiLi9zcmMvcGFzc1N0eWxlT2YuanMiOltbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXSxbImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbInRvVGhyb3dhYmxlIiwidG9UaHJvd2FibGUiXV0sIi4vc3JjL21ha2VUYWdnZWQuanMiOltbIm1ha2VUYWdnZWQiLCJtYWtlVGFnZ2VkIl1dLCIuL3NyYy9tYWtlLWZhci5qcyI6W1siUmVtb3RhYmxlIiwiUmVtb3RhYmxlIl0sWyJGYXIiLCJGYXIiXSxbIlRvRmFyRnVuY3Rpb24iLCJUb0ZhckZ1bmN0aW9uIl0sWyJHRVRfTUVUSE9EX05BTUVTIiwiR0VUX01FVEhPRF9OQU1FUyJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAeYB/DAMIAAADCAAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLGFzc2VydENoZWNrZXIsZ2V0T3duRGF0YURlc2NyaXB0b3I7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRozY9fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheSxwcm90b3R5cGU6YXJyYXlQcm90b3R5cGV9PUFycmF5O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0lNUE9SVCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjYW5CZVZhbGlkPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5pc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmY2hlY2soZmFsc2UsWCBgQXJyYXkgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7SU1QT1JUKCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyBnZXQgdG8gZmFpbC4qL1xuY29uc3QgbGVuPS8qKiBAdHlwZSB7bnVtYmVyfSAqL1xuZ2V0T3duRGF0YURlc2NyaXB0b3IoY2FuZGlkYXRlLCdsZW5ndGgnLGZhbHNlLGFzc2VydENoZWNrZXIpLnZhbHVlO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggaW5kZXggcHJvcGVydHkgaXMgb3duL2RhdGEvZW51bWVyYWJsZSovXG4vKiBhbmQgaXRzIGFzc29jaWF0ZWQgdmFsdWUgaXMgcmVjdXJzaXZlbHkgcGFzc2FibGUuKi9cbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSxpLHRydWUsYXNzZXJ0Q2hlY2tlcikudmFsdWUpO1xuXG4gfVxuLyogRXhwZWN0IG9uZSBrZXkgcGVyIGluZGV4IHBsdXMgb25lIGZvciAnbGVuZ3RoJy4qL1xub3duS2V5cyhjYW5kaWRhdGUpLmxlbmd0aD09PWxlbisxfHxcbmFzc2VydC5mYWlsKFggYEFycmF5cyBtdXN0IG5vdCBoYXZlIG5vbi1pbmRleGVzOiAke2NhbmRpZGF0ZX1gLFR5cGVFcnJvcik7XG4gfX0pOyRozY9fb25jZS5Db3B5QXJyYXlIZWxwZXIoQ29weUFycmF5SGVscGVyKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlBcnJheUhlbHBlciI6WyJDb3B5QXJyYXlIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAArHWRoUkKAABJCgAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJDb3B5UmVjb3JkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGFzc2VydENoZWNrZXIsY2FuQmVNZXRob2QsZ2V0T3duRGF0YURlc2NyaXB0b3IsQ1g7JGjNj19pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiZ2V0T3duRGF0YURlc2NyaXB0b3JcIiwgWyRozY9fYSA9PiAoZ2V0T3duRGF0YURlc2NyaXB0b3IgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0UHJvdG90eXBlT2YscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tPYmplY3RQcm90b3R5cGU9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpPT09b2JqZWN0UHJvdG90eXBlfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZWNvcmRzIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7Y2FuZGlkYXRlfWApO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtQcm9wZXJ0eUtleX0ga2V5XG4gKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxrZXksdmFsdWUsY2hlY2s9dW5kZWZpbmVkKT0+e1xucmV0dXJuKFxuKHR5cGVvZiBrZXk9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkmJihcbiFjYW5CZU1ldGhvZCh2YWx1ZSl8fFxuISFjaGVjayYmXG4vKiBUT0RPOiBVcGRhdGUgbWVzc2FnZSBub3cgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIFwiaW1wbGljaXQgUmVtb3RhYmxlXCIuKi9cbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2Fubm90IGNvbnRhaW4gbm9uLWZhciBmdW5jdGlvbnMgYmVjYXVzZSB0aGV5IG1heSBiZSBtZXRob2RzIG9mIGFuIGltcGxpY2l0IFJlbW90YWJsZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfTtcblxuLyoqXG4gKlxuICogQHR5cGUge0lNUE9SVCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5jaGVja09iamVjdFByb3RvdHlwZShjYW5kaWRhdGUsY2hlY2spJiZcbi8qIFJlamVjdCBhbnkgY2FuZGlkYXRlIHdpdGggYSBzeW1ib2wta2V5ZWQgcHJvcGVydHkgb3IgbWV0aG9kLWxpa2UgcHJvcGVydHkqL1xuLyogKHN1Y2ggaW5wdXQgaXMgcG90ZW50aWFsbHkgYSBSZW1vdGFibGUpLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkuZXZlcnkoKGtleSk9PlxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLGtleSxjYW5kaWRhdGVba2V5XSxjaGVjaykpKTtcblxuXG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2hlY2tPYmplY3RQcm90b3R5cGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggb3duIHByb3BlcnR5IGlzIGFwcHJvcHJpYXRlLCBkYXRhL2VudW1lcmFibGUsKi9cbi8qIGFuZCBoYXMgYSByZWN1cnNpdmVseSBwYXNzYWJsZSBhc3NvY2lhdGVkIHZhbHVlLiovXG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY29uc3R7dmFsdWV9PWdldE93bkRhdGFEZXNjcmlwdG9yKFxuY2FuZGlkYXRlLFxubmFtZSxcbnRydWUsXG5hc3NlcnRDaGVja2VyKTtcblxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLG5hbWUsdmFsdWUsYXNzZXJ0Q2hlY2tlcik7XG5wYXNzU3R5bGVPZlJlY3VyKHZhbHVlKTtcbiB9XG4gfX0pOyRozY9fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weVJlY29yZEhlbHBlciI6WyJDb3B5UmVjb3JkSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9wcm9taXNlLWtpdCIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIiwiLi9tYWtlVGFnZ2VkLmpzIl0sImV4cG9ydHMiOlsiZGVlcGx5RnVsZmlsbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IFgscSxFLGlzUHJvbWlzZSxnZXRUYWcsaXNPYmplY3QscGFzc1N0eWxlT2YsbWFrZVRhZ2dlZDskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRozY9fYSA9PiAoRSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJpc09iamVjdFwiLCBbJGjNj19hID0+IChpc09iamVjdCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dXV0sW1wiLi9tYWtlVGFnZ2VkLmpzXCIsIFtbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUHJpbWl0aXZlLCBDb3B5UmVjb3JkLCBDb3B5QXJyYXksIENvcHlUYWdnZWQsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSdcbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7ZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7eyBbS2V5VHlwZSBpbiBrZXlvZiBUXTogVFtLZXlUeXBlXSB9ICYge319IFNpbXBsaWZ5IGZsYXR0ZW4gdGhlXG4gKiAgIHR5cGUgb3V0cHV0IHRvIGltcHJvdmUgdHlwZSBoaW50cyBzaG93biBpbiBlZGl0b3JzXG4gKiAgIGh0dHBzOi8vZ2l0aHViLmNvbS9zaW5kcmVzb3JodXMvdHlwZS1mZXN0L2Jsb2IvbWFpbi9zb3VyY2Uvc2ltcGxpZnkuZC50c1xuICovXG5cbi8qKlxuICogQ3VycmVudGx5IGNvcGllZCBmcm9tIEBhZ29yaWMvaW50ZXJuYWwgdXRpbHMuanMuXG4gKiBUT0RPIFNob3VsZCBtaWdyYXRlIGhlcmUgYW5kIHRoZW4sIGlmIG5lZWRlZCwgcmVleHBvcnRlZCB0aGVyZS5cbiAqXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IENhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtLIGluIGtleW9mIFRdOiBUW0tdIGV4dGVuZHMgQ2FsbGFibGUgPyBUW0tdIDogRGVlcGx5QXdhaXRlZDxUW0tdPjtcbiAqIH19IERlZXBseUF3YWl0ZWRPYmplY3RcbiAqL1xuXG4vKipcbiAqIEN1cnJlbnRseSBjb3BpZWQgZnJvbSBAYWdvcmljL2ludGVybmFsIHV0aWxzLmpzLlxuICogVE9ETyBTaG91bGQgbWlncmF0ZSBoZXJlIGFuZCB0aGVuLCBpZiBuZWVkZWQsIHJlZXhwb3J0ZWQgdGhlcmUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgUHJvbWlzZUxpa2U8YW55PlxuICogICAgID8gQXdhaXRlZDxUPlxuICogICAgIDogVCBleHRlbmRzIHt9XG4gKiAgICAgICA/IFNpbXBsaWZ5PERlZXBseUF3YWl0ZWRPYmplY3Q8VD4+XG4gKiAgICAgICA6IEF3YWl0ZWQ8VD59IERlZXBseUF3YWl0ZWRcbiAqL1xuXG4vKipcbiAqIEdpdmVuIGEgUGFzc2FibGUgYHZhbGAgd2hvc2UgcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBtYXkgY29udGFpbiBsZWFmXG4gKiBwcm9taXNlcywgcmV0dXJuIGEgcHJvbWlzZSBmb3IgYSByZXBsYWNlbWVudCBQYXNzYWJsZSxcbiAqIHdoZXJlIHRoYXQgcmVwbGFjZW1lbnQgaXMgKmRlZXBseSBmdWxmaWxsZWQqLCBpLmUuLCBpdHNcbiAqIHBhc3MtYnktY29weSBzdHJ1Y3R1cmUgZG9lcyBub3QgY29udGFpbiBhbnkgcHJvbWlzZXMuXG4gKlxuICogVGhpcyBpcyBhIGRlZXAgZm9ybSBvZiBgUHJvbWlzZS5hbGxgIHNwZWNpYWxpemVkIGZvciBQYXNzYWJsZXMuIEZvciBlYWNoXG4gKiBlbmNvdW50ZXJlZCBwcm9taXNlLCByZXBsYWNlIGl0IHdpdGggdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybSBvZlxuICogaXRzIGZ1bGZpbGxtZW50LlxuICogSWYgYW55IG9mIHRoZSBwcm9taXNlcyByZWplY3QsIHRoZW4gdGhlIHByb21pc2UgZm9yIHRoZSByZXBsYWNlbWVudFxuICogcmVqZWN0cy4gSWYgYW55IG9mIHRoZSBwcm9taXNlcyBuZXZlciBzZXR0bGUsIHRoZW4gdGhlIHByb21pc2UgZm9yXG4gKiB0aGUgcmVwbGFjZW1lbnQgbmV2ZXIgc2V0dGxlcy5cbiAqXG4gKiBJZiB0aGUgcmVwbGFjZW1lbnQgd291bGQgbm90IGJlIFBhc3NhYmxlLCBpLmUuLCBpZiBgdmFsYCBpcyBub3RcbiAqIFBhc3NhYmxlLCBvciBpZiBhbnkgb2YgdGhlIHRyYW5zaXRpdmUgcHJvbWlzZXMgZnVsZmlsbCB0byBzb21ldGhpbmdcbiAqIHRoYXQgaXMgbm90IFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBwcm9taXNlIHJlamVjdHMuXG4gKlxuICogSWYgYHZhbGAgb3IgaXRzIHBhcnRzIGFyZSBub24ta2V5IFBhc3NhYmxlcyBvbmx5ICpiZWNhdXNlKiB0aGV5IGNvbnRhaW5cbiAqIHByb21pc2VzLCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtcyBvZiB2YWwgb3IgaXRzIHBhcnRzIG1heSBiZSBrZXlzLiBUaGlzXG4gKiBpcyBmb3IgdGhlIGhpZ2hlciBcIkBlbmRvL3BhdHRlcm5zXCIgbGV2ZWwgb2YgYWJzdHJhY3Rpb24gdG8gZGV0ZXJtaW5lLFxuICogYmVjYXVzZSBpdCBkZWZpbmVzIHRoZSBgS2V5YCBub3Rpb24gaW4gcXVlc3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Q9UGFzc2FibGVdXG4gKiBAcGFyYW0ge1R9IHZhbFxuICogQHJldHVybnMge1Byb21pc2U8RGVlcGx5QXdhaXRlZDxUPj59XG4gKi9cbmNvbnN0ICAgICAgICBkZWVwbHlGdWxmaWxsZWQ9YXN5bmModmFsKT0+e1xuLyogVE9ETyBGaWd1cmUgb3V0IHdoeSB3ZSBuZWVkIHRoZXNlIGF0LWV4cGVjdC1lcnJvciBkaXJlY3RpdmVzIGJlbG93Ki9cbi8qIGFuZCBmaXggaWYgcG9zc2libGUuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTI1NyBtYXkgYmUgcmVsZXZhbnQuKi9cblxuaWYoIWlzT2JqZWN0KHZhbCkpe1xucmV0dXJuICgvKiogQHR5cGUge0RlZXBseUF3YWl0ZWQ8VD59ICovdmFsKTtcbiB9XG5pZihpc1Byb21pc2UodmFsKSl7XG5yZXR1cm4gRS53aGVuKHZhbCwobm9ucCk9PmRlZXBseUZ1bGZpbGxlZChub25wKSk7XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbCk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnY29weVJlY29yZCc6e1xuY29uc3QgcmVjPS8qKiBAdHlwZSB7Q29weVJlY29yZH0gKi92YWw7XG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjKTtcbmNvbnN0IHZhbFBzPW5hbWVzLm1hcCgobmFtZSk9PmRlZXBseUZ1bGZpbGxlZChyZWNbbmFtZV0pKTtcbi8qIEB0cy1leHBlY3QtZXJyb3Igbm90IGFzc2lnbmFibGUgdG8gdHlwZSAnRGVlcGx5QXdhaXRlZDxUPicqL1xucmV0dXJuIEUud2hlbihQcm9taXNlLmFsbCh2YWxQcyksKHZhbHMpPT5cbmhhcmRlbihmcm9tRW50cmllcyh2YWxzLm1hcCgoYyxpKT0+W25hbWVzW2ldLGNdKSkpKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5jb25zdCBhcnI9LyoqIEB0eXBlIHtDb3B5QXJyYXl9ICovdmFsO1xuY29uc3QgdmFsUHM9YXJyLm1hcCgocCk9PmRlZXBseUZ1bGZpbGxlZChwKSk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oUHJvbWlzZS5hbGwodmFsUHMpLCh2YWxzKT0+aGFyZGVuKHZhbHMpKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGdkPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi92YWw7XG5jb25zdCB0YWc9Z2V0VGFnKHRnZCk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oZGVlcGx5RnVsZmlsbGVkKHRnZC5wYXlsb2FkKSwocGF5bG9hZCk9PlxubWFrZVRhZ2dlZCh0YWcscGF5bG9hZCkpO1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IHJlbT0vKiogQHR5cGUge1JlbW90YWJsZU9iamVjdH0gKi92YWw7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiByZW07XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZXJyPS8qKiBAdHlwZSB7RXJyb3J9ICovdmFsO1xuLyogQHRzLWV4cGVjdC1lcnJvciBub3QgYXNzaWduYWJsZSB0byB0eXBlICdEZWVwbHlBd2FpdGVkPFQ+JyovXG5yZXR1cm4gZXJyO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcHJvbT0vKiogQHR5cGUge1Byb21pc2V9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi92YWw7XG5yZXR1cm4gRS53aGVuKHByb20sKG5vbnApPT5kZWVwbHlGdWxmaWxsZWQobm9ucCkpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoWCBgVW5leHBlY3RlZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9YCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9OyRozY9fb25jZS5kZWVwbHlGdWxmaWxsZWQoZGVlcGx5RnVsZmlsbGVkKTtcbmhhcmRlbihkZWVwbHlGdWxmaWxsZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVlcGx5RnVsZmlsbGVkIjpbImRlZXBseUZ1bGZpbGxlZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABREv3gLhsAAC4bAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yIiwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiLCJnZXRFcnJvckNvbnN0cnVjdG9yIiwiaXNFcnJvckxpa2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcSxhc3NlcnRDaGVja2VyLENYOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlSGVscGVyfSBmcm9tICcuL2ludGVybmFsLXR5cGVzLmpzJyAqL1xuLyoqIEBpbXBvcnQge0NoZWNrZXIsIFBhc3NTdHlsZSwgUGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsaGFzT3duLGVudHJpZXN9PU9iamVjdDtcblxuLyogVE9ETzogTWFpbnRlbmFuY2UgaGF6YXJkOiBDb29yZGluYXRlIHdpdGggdGhlIGxpc3Qgb2YgZXJyb3JzIGluIHRoZSBTRVMqL1xuLyogd2hpbGVsaXN0LiovXG5jb25zdCBlcnJvckNvbnN0cnVjdG9ycz1uZXcgTWFwKFxuLyogQ2FzdCBiZWNhdXNlIG90aGVyd2lzZSBUUyBpcyBjb25mdXNlZCBieSBBZ2dyZWdhdGVFcnJvciovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMjA0MiNkaXNjdXNzaW9uX3IxNDg0OTMzMDI4Ki9cbi8qKiBAdHlwZSB7QXJyYXk8W3N0cmluZywgSU1QT1JUKCdzZXMnKS5HZW5lcmljRXJyb3JDb25zdHJ1Y3Rvcl0+fSAqL1xuW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1cblxuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy81NTAqL1xuLyogVG8gYWNjb21tb2RhdGUgcGxhdGZvcm1zIHByaW9yIHRvIEFnZ3JlZ2F0ZUVycm9yLCB3ZSBjb21tZW50IG91dCB0aGUqL1xuLyogZm9sbG93aW5nIGxpbmUgYW5kIGluc3RlYWQgY29uZGl0aW9uYWxseSBhZGQgaXQgdG8gdGhlIG1hcCBiZWxvdy4qL1xuLyogWydBZ2dyZWdhdGVFcnJvcicsIEFnZ3JlZ2F0ZUVycm9yXSwqL10pO1xuXG5cblxuaWYodHlwZW9mIEFnZ3JlZ2F0ZUVycm9yIT09J3VuZGVmaW5lZCcpe1xuLyogQ29uZGl0aW9uYWwsIHRvIGFjY29tbW9kYXRlIHBsYXRmb3JtcyBwcmlvciB0byBBZ2dyZWdhdGVFcnJvciovXG5lcnJvckNvbnN0cnVjdG9ycy5zZXQoJ0FnZ3JlZ2F0ZUVycm9yJyxBZ2dyZWdhdGVFcnJvcik7XG4gfVxuXG4vKipcbiAqIEJlY2F1c2UgdGhlIGVycm9yIGNvbnN0cnVjdG9yIHJldHVybmVkIGJ5IHRoaXMgZnVuY3Rpb24gbWlnaHQgYmVcbiAqIGBBZ2dyZWdhdGVFcnJvcmAsIHdoaWNoIGhhcyBkaWZmZXJlbnQgY29uc3RydWN0aW9uIHBhcmFtZXRlcnNcbiAqIGZyb20gdGhlIG90aGVyIGVycm9yIGNvbnN0cnVjdG9ycywgZG8gbm90IHVzZSBpdCBkaXJlY3RseSB0byB0cnlcbiAqIHRvIG1ha2UgYW4gZXJyb3IgaW5zdGFuY2UuIFJhdGhlciwgdXNlIGBtYWtlRXJyb3JgIHdoaWNoIGVuY2Fwc3VsYXRlc1xuICogdGhpcyBub24tdW5pZm9ybWl0eS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge0lNUE9SVCgnc2VzJykuR2VuZXJpY0Vycm9yQ29uc3RydWN0b3IgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRFcnJvckNvbnN0cnVjdG9yPShuYW1lKT0+ZXJyb3JDb25zdHJ1Y3RvcnMuZ2V0KG5hbWUpOyRozY9fb25jZS5nZXRFcnJvckNvbnN0cnVjdG9yKGdldEVycm9yQ29uc3RydWN0b3IpO1xuaGFyZGVuKGdldEVycm9yQ29uc3RydWN0b3IpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja0Vycm9yTGlrZT0oY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9Pntcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxuISFjaGVjayYmQ1goY2hlY2spIGBFcnJvciBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbiB9O1xuaGFyZGVuKGNoZWNrRXJyb3JMaWtlKTtcbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogVmFsaWRhdGluZyBlcnJvciBvYmplY3RzIGFyZSBwYXNzYWJsZSByYWlzZXMgYSB0ZW5zaW9uIGJldHdlZW4gc2VjdXJpdHlcbiAqIHZzIHByZXNlcnZpbmcgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gRm9yIGVycm9ycywgd2UgbmVlZCB0byByZW1lbWJlclxuICogdGhlIGVycm9yIGl0c2VsZiBleGlzdHMgdG8gaGVscCB1cyBkaWFnbm9zZSBhIGJ1ZyB0aGF0J3MgbGlrZWx5IG1vcmVcbiAqIHByZXNzaW5nIHRoYW4gYSB2YWxpZGl0eSBidWcgaW4gdGhlIGVycm9yIGl0c2VsZi4gVGh1cywgd2hlbmV2ZXIgaXQgaXMgc2FmZVxuICogdG8gZG8gc28sIHdlIHByZWZlciB0byBsZXQgdGhlIGVycm9yLWxpa2UgdGVzdCBzdWNjZWVkIGFuZCB0byBjb3VjaCB0aGVzZVxuICogY29tcGxhaW50cyBhcyBub3RlcyBvbiB0aGUgZXJyb3IuXG4gKlxuICogVG8gcmVzb2x2ZSB0aGlzLCBzdWNoIGEgbWFsZm9ybWVkIGVycm9yIG9iamVjdCB3aWxsIHN0aWxsIHBhc3NcbiAqIGBpc0Vycm9yTGlrZWAgc28gbWFyc2hhbCBjYW4gdXNlIHRoaXMgZm9yIHRvcCBsZXZlbCBlcnJvciB0byByZXBvcnQgZnJvbSxcbiAqIGV2ZW4gaWYgaXQgd291bGQgbm90IGFjdHVhbGx5IHZhbGlkYXRlLlxuICogSW5zdGVhZCwgdGhlIGRpYWdub3N0aWNzIHRoYXQgYGFzc2VydEVycm9yYCB3b3VsZCBoYXZlIHJlcG9ydGVkIGFyZVxuICogYXR0YWNoZWQgYXMgbm90ZXMgdG8gdGhlIG1hbGZvcm1lZCBlcnJvci4gVGh1cywgYSBtYWxmb3JtZWRcbiAqIGVycm9yIGlzIHBhc3NhYmxlIGJ5IGl0c2VsZiwgYnV0IG5vdCBhcyBwYXJ0IG9mIGEgcGFzc2FibGUgc3RydWN0dXJlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzRXJyb3JMaWtlPShjYW5kaWRhdGUpPT5jaGVja0Vycm9yTGlrZShjYW5kaWRhdGUpOyRozY9fb25jZS5pc0Vycm9yTGlrZShpc0Vycm9yTGlrZSk7XG5oYXJkZW4oaXNFcnJvckxpa2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBwcm9wTmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEBwYXJhbSB7KHZhbDogYW55KSA9PiBQYXNzU3R5bGV9IHBhc3NTdHlsZU9mUmVjdXJcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYz0oXG5wcm9wTmFtZSxcbmRlc2MsXG5wYXNzU3R5bGVPZlJlY3VyLFxuY2hlY2s9dW5kZWZpbmVkKT0+XG57XG5pZihkZXNjLmVudW1lcmFibGUpe1xucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yICR7cShcbnByb3BOYW1lKVxuIH0gb3duIHByb3BlcnR5IG11c3Qgbm90IGJlIGVudW1lcmFibGU6ICR7ZGVzY31gKTtcblxuIH1cbmlmKCFoYXNPd24oZGVzYywndmFsdWUnKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGRhdGEgcHJvcGVydHk6ICR7ZGVzY31gKTtcblxuIH1cbmNvbnN0e3ZhbHVlfT1kZXNjO1xuc3dpdGNoKHByb3BOYW1lKXtcbmNhc2UnbWVzc2FnZSc6XG5jYXNlJ3N0YWNrJzp7XG5yZXR1cm4oXG50eXBlb2YgdmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt2YWx1ZX1gKTtcblxuIH1cbmNhc2UnY2F1c2UnOntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IodmFsdWUscGFzc1N0eWxlT2ZSZWN1cixjaGVjayk7XG4gfVxuY2FzZSdlcnJvcnMnOntcbmlmKCFBcnJheS5pc0FycmF5KHZhbHVlKXx8cGFzc1N0eWxlT2ZSZWN1cih2YWx1ZSkhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGNvcHlBcnJheTogJHt2YWx1ZX1gKTtcblxuIH1cbnJldHVybiB2YWx1ZS5ldmVyeSgoZXJyKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mUmVjdXIsY2hlY2spKTtcblxuIH1cbmRlZmF1bHQ6e1xuYnJlYWs7XG4gfX1cblxucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yIGhhcyBleHRyYSB1bnBhc3NlZCBwcm9wZXJ0eSAke3EocHJvcE5hbWUpfWApO1xuXG4gfTskaM2PX29uY2UuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MpO1xuaGFyZGVuKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHsodmFsOiBhbnkpID0+IFBhc3NTdHlsZX0gcGFzc1N0eWxlT2ZSZWN1clxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yPShcbmNhbmRpZGF0ZSxcbnBhc3NTdHlsZU9mUmVjdXIsXG5jaGVjaz11bmRlZmluZWQpPT5cbntcbmlmKCFjaGVja0Vycm9yTGlrZShjYW5kaWRhdGUsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpO1xuY29uc3R7bmFtZX09cHJvdG87XG5jb25zdCBlcnJDb25zdHJ1Y3Rvcj1nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpO1xuaWYoZXJyQ29uc3RydWN0b3I9PT11bmRlZmluZWR8fGVyckNvbnN0cnVjdG9yLnByb3RvdHlwZSE9PXByb3RvKXtcbnJldHVybihcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgUGFzc2FibGUgRXJyb3IgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCk7XG5cbiB9XG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZighKCdtZXNzYWdlJ2luIGRlc2NzKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFBhc3NhYmxlIEVycm9yIG11c3QgaGF2ZSBhbiBvd24gXCJtZXNzYWdlXCIgc3RyaW5nIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTtcblxuIH1cblxucmV0dXJuIGVudHJpZXMoZGVzY3MpLmV2ZXJ5KChbcHJvcE5hbWUsZGVzY10pPT5cbmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKFxucHJvcE5hbWUsXG5kZXNjLFxucGFzc1N0eWxlT2ZSZWN1cixcbmNoZWNrKSk7XG5cblxuIH07JGjNj19vbmNlLmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKTtcbmhhcmRlbihjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcik7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+XG5jaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cixhc3NlcnRDaGVja2VyKX0pOyRozY9fb25jZS5FcnJvckhlbHBlcihFcnJvckhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAu5h1k2cIAABnCAAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiLi9tYWtlLWZhci5qcyJdLCJleHBvcnRzIjpbImZpbHRlckl0ZXJhYmxlIiwibWFwSXRlcmFibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgRmFyOyRozY9faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaM2PX2EgPT4gKEZhciA9ICRozY9fYSldXV1dXSk7ICAgXG5cbi8qKlxuICogVGhlIHJlc3VsdCBpdGVyYXRvciBoYXMgYXMgbWFueSBlbGVtZW50cyBhcyB0aGUgYGJhc2VJdGVyYXRvcmAgYW5kXG4gKiBoYXZlIHRoZSBzYW1lIHRlcm1pbmF0aW9uIC0tIHRoZSBzYW1lIGNvbXBsZXRpb24gdmFsdWUgb3IgZmFpbHVyZVxuICogcmVhc29uLiBCdXQgdGhlIG5vbi1maW5hbCB2YWx1ZXMgYXJlIHRoZSBjb3JyZXNwb25kaW5nIG5vbi1maW5hbFxuICogdmFsdWVzIGZyb20gYGJhc2VJdGVyYXRvcmAgYXMgdHJhbnNmb3JtZWQgYnkgYGZ1bmNgLlxuICpcbiAqIEB0ZW1wbGF0ZSBULFVcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IGJhc2VJdGVyYWJsZVxuICogQHBhcmFtIHsodmFsdWU6IFQpID0+IFV9IGZ1bmNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxVPn1cbiAqL1xuY29uc3QgICAgICAgIG1hcEl0ZXJhYmxlPShiYXNlSXRlcmFibGUsZnVuYyk9PlxuLyoqIEB0eXBlIHtJdGVyYWJsZTxVPn0gKi9cbkZhcignbWFwcGVkIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgYmFzZUl0ZXJhdG9yPWJhc2VJdGVyYWJsZVtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gRmFyKCdtYXBwZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmNvbnN0e3ZhbHVlOmJhc2VWYWx1ZSxkb25lfT1iYXNlSXRlcmF0b3IubmV4dCgpO1xuY29uc3QgdmFsdWU9ZG9uZT9iYXNlVmFsdWU6ZnVuYyhiYXNlVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7dmFsdWUsZG9uZX0pO1xuIH19KTtcblxuIH19KTskaM2PX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjNj19vbmNlLmZpbHRlckl0ZXJhYmxlKGZpbHRlckl0ZXJhYmxlKTtcblxuaGFyZGVuKGZpbHRlckl0ZXJhYmxlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1hcEl0ZXJhYmxlIjpbIm1hcEl0ZXJhYmxlIl0sImZpbHRlckl0ZXJhYmxlIjpbImZpbHRlckl0ZXJhYmxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN5jxppcJAAAXCQAACcAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZS1mYXIuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyIsIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3JlbW90YWJsZS5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkdFVF9NRVRIT0RfTkFNRVMiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldE1ldGhvZE5hbWVzLHEsRmFpbCxhc3NlcnRDaGVja2VyLFBBU1NfU1RZTEUsYXNzZXJ0SWZhY2UsZ2V0SW50ZXJmYWNlT2YsUmVtb3RhYmxlSGVscGVyOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qc1wiLCBbW1wiZ2V0TWV0aG9kTmFtZXNcIiwgWyRozY9fYSA9PiAoZ2V0TWV0aG9kTmFtZXMgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcImFzc2VydElmYWNlXCIsIFskaM2PX2EgPT4gKGFzc2VydElmYWNlID0gJGjNj19hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaM2PX2EgPT4gKGdldEludGVyZmFjZU9mID0gJGjNj19hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge1JlbW90YWJsZUJyYW5kfSBmcm9tICdAZW5kby9ldmVudHVhbC1zZW5kJyAqL1xuLyoqIEBpbXBvcnQge0ludGVyZmFjZVNwZWMsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuY29uc3R7cHJvdG90eXBlOmZ1bmN0aW9uUHJvdG90eXBlfT1GdW5jdGlvbjtcbmNvbnN0e1xuZ2V0UHJvdG90eXBlT2YsXG5zZXRQcm90b3R5cGVPZixcbmNyZWF0ZSxcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09XG5PYmplY3Q7XG5cbi8qKlxuICogTm93IHRoYXQgdGhlIHJlbW90YWJsZVByb3RvIGRvZXMgbm90IHByb3ZpZGUgaXRzIG93biBgdG9TdHJpbmdgIG1ldGhvZCxcbiAqIGVuc3VyZSBpdCBhbHdheXMgaW5oZXJpdHMgZnJvbSBzb21ldGhpbmcuIFRoZSBvcmlnaW5hbCBwcm90b3R5cGUgb2ZcbiAqIGByZW1vdGFibGVgIGlmIHRoZXJlIHdhcyBvbmUsIG9yIGBPYmplY3QucHJvdG90eXBlYCBvdGhlcndpc2UuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IHJlbW90YWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHJldHVybnMge29iamVjdH1cbiAqL1xuY29uc3QgbWFrZVJlbW90YWJsZVByb3RvPShyZW1vdGFibGUsaWZhY2UpPT57XG5sZXQgb2xkUHJvdG89Z2V0UHJvdG90eXBlT2YocmVtb3RhYmxlKTtcbmlmKHR5cGVvZiByZW1vdGFibGU9PT0nb2JqZWN0Jyl7XG5pZihvbGRQcm90bz09PW51bGwpe1xub2xkUHJvdG89b2JqZWN0UHJvdG90eXBlO1xuIH1cbm9sZFByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbkZhaWwgYEZvciBub3csIHJlbW90YWJsZXMgY2Fubm90IGluaGVyaXQgZnJvbSBhbnl0aGluZyB1bnVzdWFsLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNlIGlmKHR5cGVvZiByZW1vdGFibGU9PT0nZnVuY3Rpb24nKXtcbm9sZFByb3RvIT09bnVsbHx8XG5GYWlsIGBPcmlnaW5hbCBmdW5jdGlvbiBtdXN0IG5vdCBpbmhlcml0IGZyb20gbnVsbDogJHtyZW1vdGFibGV9YDtcbm9sZFByb3RvPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuZ2V0UHJvdG90eXBlT2Yob2xkUHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuRmFpbCBgRmFyIGZ1bmN0aW9ucyBtdXN0IG9yaWdpbmFsbHkgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZSwgaW4gJHtyZW1vdGFibGV9YDtcbiB9ZWxzZXtcbkZhaWwgYHVucmVjb2duaXplZCB0eXBlb2YgJHtyZW1vdGFibGV9YDtcbiB9XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9sZFByb3RvLHtcbltQQVNTX1NUWUxFXTp7dmFsdWU6J3JlbW90YWJsZSd9LFxuW1N5bWJvbC50b1N0cmluZ1RhZ106e3ZhbHVlOmlmYWNlfX0pKTtcblxuXG4gfTtcblxuY29uc3QgYXNzZXJ0Q2FuQmVSZW1vdGFibGU9KGNhbmRpZGF0ZSk9PlxuUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENyZWF0ZSBhbmQgcmVnaXN0ZXIgYSBSZW1vdGFibGUuICBBZnRlciB0aGlzLCBnZXRJbnRlcmZhY2VPZihyZW1vdGFibGUpXG4gKiByZXR1cm5zIGlmYWNlLlxuICpcbiAqIC8vIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvODA0XG4gKlxuICogQHRlbXBsYXRlIHt7fX0gVFxuICogQHRlbXBsYXRlIHtJbnRlcmZhY2VTcGVjfSBJXG4gKiBAcGFyYW0ge0l9IFtpZmFjZV0gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHNdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlT2JqZWN0PEk+ICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fX0gcmVtb3RhYmxlLCBtb2RpZmllZCBmb3IgZGVidWdnYWJpbGl0eVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlPShcbi8qIEB0cy1leHBlY3QtZXJyb3IgSSBjb3VsZCBoYXZlIGRpZmZlcmVudCBzdWJ0eXBlIHRoYW4gc3RyaW5nKi9cbmlmYWNlPSdSZW1vdGFibGUnLFxucHJvcHM9dW5kZWZpbmVkLFxucmVtb3RhYmxlPS8qKiBAdHlwZSB7VH0gKi97fSk9Plxue1xuYXNzZXJ0SWZhY2UoaWZhY2UpO1xuYXNzZXJ0KGlmYWNlKTtcbi8qIFRPRE86IFdoZW4gaWZhY2UgaXMgcmljaGVyIHRoYW4ganVzdCBzdHJpbmcsIHdlIG5lZWQgdG8gZ2V0IHRoZSBhbGxlZ2VkTmFtZSovXG4vKiBpbiBhIGRpZmZlcmVudCB3YXkuKi9cbnByb3BzPT09dW5kZWZpbmVkfHxGYWlsIGBSZW1vdGFibGUgcHJvcHMgbm90IHlldCBpbXBsZW1lbnRlZCAke3Byb3BzfWA7XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgdGhhdCB0aGUgdW5tb2RpZmllZCBvYmplY3QgaXMgYWJsZSB0byBiZWNvbWUgYSBSZW1vdGFibGUuKi9cbmFzc2VydENhbkJlUmVtb3RhYmxlKHJlbW90YWJsZSk7XG5cbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBtYXJrZWQuKi9cbiEoUEFTU19TVFlMRSBpbiByZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBtYXJrZWQgYXMgYSAke3EoXG5yZW1vdGFibGVbUEFTU19TVFlMRV0pXG4gfWA7XG4vKiBgaXNGcm96ZW5gIGFsd2F5cyByZXR1cm5zIHRydWUgd2l0aCBhIGZha2UgYGhhcmRlbmAsIGJ1dCB3ZSB3YW50IHRoYXQgY2FzZSovXG4vKiB0byBzdWNjZWVkIGFueXdheS4gRmFraW5nIGBoYXJkZW5gIGlzIG9ubHkgY29ycmVjdG5lc3MgcHJlc2VydmluZyovXG4vKiBpZiB0aGUgY29kZSBpbiBxdWVzdGlvbiBjb250YWlucyBubyBidWdzIHRoYXQgdGhlIHJlYWwgYGhhcmRlbmAgd291bGQqL1xuLyogaGF2ZSBjYXVnaHQuKi9cbi8qIEB0cy1pZ25vcmUgYGlzRmFrZWAgcHVycG9zZWx5IG5vdCBpbiB0aGUgdHlwZSovXG5oYXJkZW4uaXNGYWtlfHxcbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBmcm96ZW4uKi9cbiFpc0Zyb3plbihyZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBmcm96ZW5gO1xuY29uc3QgcmVtb3RhYmxlUHJvdG89bWFrZVJlbW90YWJsZVByb3RvKHJlbW90YWJsZSxpZmFjZSk7XG5cbi8qIFRha2UgYSBzdGF0aWMgY29weSBvZiB0aGUgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBhcyBkYXRhIHByb3BlcnRpZXMuKi9cbi8qIGNvbnN0IHByb3BEZXNjcyA9IGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoeyAuLi5wcm9wcyB9KTsqL1xuY29uc3QgbXV0YXRlSGFyZGVuQW5kQ2hlY2s9KHRhcmdldCk9Pntcbi8qIGRlZmluZVByb3BlcnRpZXModGFyZ2V0LCBwcm9wRGVzY3MpOyovXG5zZXRQcm90b3R5cGVPZih0YXJnZXQscmVtb3RhYmxlUHJvdG8pO1xuaGFyZGVuKHRhcmdldCk7XG5hc3NlcnRDYW5CZVJlbW90YWJsZSh0YXJnZXQpO1xuIH07XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgYSBmcmVzaCByZW1vdGFibGUgdG8gc2VlIGlmIG91ciBydWxlcyBmaXQuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHt9KTtcblxuLyogQWN0dWFsbHkgZmluaXNoIHRoZSBuZXcgcmVtb3RhYmxlLiovXG5tdXRhdGVIYXJkZW5BbmRDaGVjayhyZW1vdGFibGUpO1xuXG4vKiBDT01NSVRURUQhKi9cbi8qIFdlJ3JlIGNvbW1pdHRlZCwgc28ga2VlcCB0aGUgaW50ZXJmYWNlIGZvciBmdXR1cmUgcmVmZXJlbmNlLiovXG5hc3NlcnQoaWZhY2UhPT11bmRlZmluZWQpOy8qIFRvIG1ha2UgVHlwZVNjcmlwdCBoYXBweSovXG5yZXR1cm4gKC8qKiBAdHlwZSB7YW55fSAqL3JlbW90YWJsZSk7XG4gfTskaM2PX29uY2UuUmVtb3RhYmxlKFJlbW90YWJsZSk7XG5oYXJkZW4oUmVtb3RhYmxlKTtcblxuLyoqXG4gKiBUaGUgbmFtZSBvZiB0aGUgYXV0b21hdGljYWxseSBhZGRlZCBkZWZhdWx0IG1ldGEtbWV0aG9kIGZvciBvYnRhaW5pbmcgYVxuICogbGlzdCBvZiBhbGwgbWV0aG9kcyBvZiBhbiBvYmplY3QgZGVjbGFyZWQgd2l0aCBgRmFyYCwgb3IgYW4gb2JqZWN0IHRoYXRcbiAqIGluaGVyaXRzIGZyb20gYW4gb2JqZWN0IGRlY2xhcmVkIHdpdGggYEZhcmAuXG4gKlxuICogTW9kZWxlZCBvbiBgR0VUX0lOVEVSRkFDRV9HVUFSRGAgZnJvbSBgQGVuZG8vZXhvYC5cbiAqXG4gKiBUT0RPIE5hbWUgdG8gYmUgYmlrZXNoZWQuIFBlcmhhcHMgZXZlbiB3aGV0aGVyIGl0IGlzIGFcbiAqIHN0cmluZyBvciBzeW1ib2wgdG8gYmUgYmlrZXNoZWQuIFNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTgwOSNkaXNjdXNzaW9uX3IxMzg4MDUyNDU0XG4gKlxuICogSEFaQVJEOiBCZXdhcmUgdGhhdCBhbiBleG8ncyBpbnRlcmZhY2UgY2FuIGNoYW5nZSBhY3Jvc3MgYW4gdXBncmFkZSxcbiAqIHNvIHJlbW90ZXMgdGhhdCBjYWNoZSBpdCBjYW4gYmVjb21lIHN0YWxlLlxuICovXG5jb25zdCAgICAgICAgR0VUX01FVEhPRF9OQU1FUz0nX19nZXRNZXRob2ROYW1lc19fJztcblxuLyoqXG4gKiBOb3RlIHRoYXQgYGdldE1ldGhvZE5hbWVzTWV0aG9kYCBpcyBhIHRoaXNmdWwgbWV0aG9kISBJdCBtdXN0IGJlIHNvIHRoYXRcbiAqIGl0IHdvcmtzIGFzIGV4cGVjdGVkIHdpdGggZmFyLW9iamVjdCBpbmhlcml0YW5jZS5cbiAqXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi8kaM2PX29uY2UuR0VUX01FVEhPRF9OQU1FUyhHRVRfTUVUSE9EX05BTUVTKTtcbmNvbnN0IGdldE1ldGhvZE5hbWVzTWV0aG9kPWhhcmRlbih7XG5bR0VUX01FVEhPRF9OQU1FU10oKXtcbnJldHVybiBnZXRNZXRob2ROYW1lcyh0aGlzKTtcbiB9fSlbXG5HRVRfTUVUSE9EX05BTUVTXTtcblxuY29uc3QgZ2V0TWV0aG9kTmFtZXNEZXNjcmlwdG9yPWhhcmRlbih7XG52YWx1ZTpnZXRNZXRob2ROYW1lc01ldGhvZCxcbmVudW1lcmFibGU6ZmFsc2UsXG5jb25maWd1cmFibGU6ZmFsc2UsXG53cml0YWJsZTpmYWxzZX0pO1xuXG5cbi8qKlxuICogTWFyayBhbiBvYmplY3QgdG8gYmUgZXhwb3NlZCBmb3IgcmVtb3RlIGludGVyYWN0aW9uXG4gKiBhbmQgZ2l2ZSBpdCBhIHN1Z2dlc3RpdmUgaW50ZXJmYWNlIG5hbWUgZm9yIGRlYnVnZ2luZy5cbiAqXG4gKiBBbGwgcHJvcGVydGllcyBvZiB0aGUgb2JqZWN0IGhhdmUgdG8gYmUgbWV0aG9kcywgbm90IGRhdGEuXG4gKlxuICogVGhlIG9iamVjdCBtdXN0IG5vdCBiZSBoYXJkZW5lZCBiZWZvcmUgaXQgaXMgbWFya2VkLlxuICogSXQgd2lsbCBiZSBoYXJkZW5lZCBhZnRlciBtYXJraW5nLlxuICpcbiAqIEZvciBmYXIgb2JqZWN0cyAoYXMgb3Bwb3NlZCB0byBmYXIgZnVuY3Rpb25zKSwgYWxzbyBhZGRzXG4gKiBgX19nZXRNZXRob2ROYW1lc19fYCBtZXRob2QgdGhhdCByZXR1cm5zIGFuIGFycmF5IG9mIGFsbCB0aGUgbWV0aG9kIG5hbWVzLFxuICogaWYgdGhlcmUgaXMgbm90IHlldCBhbnkgbWV0aG9kIG5hbWVkIGBfX2dldE1ldGhvZE5hbWVzX19gLlxuICpcbiAqIEBleGFtcGxlXG4gKiBGYXIoJ0VtcGxveWVlJywgeyBnZXRNYW5hZ2VyIH0pXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZmFyTmFtZSBUaGlzIG5hbWUgd2lsbCBiZSBwcmVwZW5kZWQgd2l0aCBgQWxsZWdlZDogYFxuICogZm9yIG5vdyB0byBmb3JtIHRoZSBgUmVtb3RhYmxlYCBgaWZhY2VgIGFyZ3VtZW50LlxuICogQHBhcmFtIHtUfSBbcmVtb3RhYmxlXSBUaGUgb2JqZWN0IHRvIGJlIG1hcmtlZCBhcyByZW1vdGFibGVcbiAqL1xuY29uc3QgICAgICAgIEZhcj0oZmFyTmFtZSxyZW1vdGFibGU9dW5kZWZpbmVkKT0+e1xuY29uc3Qgcj1yZW1vdGFibGU9PT11bmRlZmluZWQ/LyoqIEB0eXBlIHtUfSAqL3t9OnJlbW90YWJsZTtcbmlmKHR5cGVvZiByPT09J29iamVjdCcmJiEoR0VUX01FVEhPRF9OQU1FUyBpbiByKSl7XG4vKiBUaGlzIHRlc3QgZXhjbHVkZXMgZmFyIGZ1bmN0aW9ucywgc2luY2Ugd2UgY3VycmVudGx5IGNvbnNpZGVyIHRoZW0qL1xuLyogdG8gb25seSBoYXZlIGEgY2FsbC1iZWhhdmlvciwgd2l0aCBubyBjYWxsYWJsZSBtZXRob2RzLiovXG4vKiBCZXdhcmU6IE11dGF0ZXMgdGhlIGlucHV0IGFyZ3VtZW50ISBCdXQgYFJlbW90YWJsZWAqL1xuLyogKiByZXF1aXJlcyB0aGUgb2JqZWN0IHRvIGJlIG11dGFibGUqL1xuLyogKiBkb2VzIGZ1cnRoZXIgbXV0YXRpb25zLCovXG4vKiAqIGhhcmRlbnMgdGhlIG11dGF0ZWQgb2JqZWN0IGJlZm9yZSByZXR1cm5pbmcgaXQuKi9cbi8qIHNvIHRoaXMgbXV0YXRpb24gaXMgbm90IHVucHJlY2VkZW50ZWQuIEJ1dCBpdCBpcyBzdXJwcmlzaW5nISovXG5PYmplY3QuZGVmaW5lUHJvcGVydHkocixHRVRfTUVUSE9EX05BTUVTLGdldE1ldGhvZE5hbWVzRGVzY3JpcHRvcik7XG4gfVxucmV0dXJuIFJlbW90YWJsZSggYEFsbGVnZWQ6ICR7ZmFyTmFtZX1gLHVuZGVmaW5lZCxyKTtcbiB9OyRozY9fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gRlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0ge0Z9IGZ1bmNcbiAqIEByZXR1cm5zIHtGICYgUmVtb3RhYmxlT2JqZWN0ICYgUmVtb3RhYmxlQnJhbmQ8e30sIEY+fVxuICovXG5jb25zdCAgICAgICAgVG9GYXJGdW5jdGlvbj0oZmFyTmFtZSxmdW5jKT0+e1xuaWYoZ2V0SW50ZXJmYWNlT2YoZnVuYykhPT11bmRlZmluZWQpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjaGVja2VkIGNhc3QqL1xucmV0dXJuIGZ1bmM7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBjb3VsZCBiZSBkaWZmZXJlbnQgc3VidHlwZSovXG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRozY9fb25jZS5Ub0ZhckZ1bmN0aW9uKFRvRmFyRnVuY3Rpb24pO1xuaGFyZGVuKFRvRmFyRnVuY3Rpb24pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUmVtb3RhYmxlIjpbIlJlbW90YWJsZSJdLCJHRVRfTUVUSE9EX05BTUVTIjpbIkdFVF9NRVRIT0RfTkFNRVMiXSwiRmFyIjpbIkZhciJdLCJUb0ZhckZ1bmN0aW9uIjpbIlRvRmFyRnVuY3Rpb24iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGVoiOh4FAAAeBQAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIl0sImV4cG9ydHMiOlsibWFrZVRhZ2dlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLFBBU1NfU1RZTEUsYXNzZXJ0UGFzc2FibGU7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBUXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQXG4gKiBAcGFyYW0ge1R9IHRhZ1xuICogQHBhcmFtIHtQfSBwYXlsb2FkXG4gKiBAcmV0dXJucyB7SU1QT1JUKCcuL3R5cGVzLmpzJykuQ29weVRhZ2dlZDxULFA+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRozY9fb25jZS5tYWtlVGFnZ2VkKG1ha2VUYWdnZWQpO1xuaGFyZGVuKG1ha2VUYWdnZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRhZ2dlZCI6WyJtYWtlVGFnZ2VkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiQ1giLCJQQVNTX1NUWUxFIiwiYXNzZXJ0Q2hlY2tlciIsImNhbkJlTWV0aG9kIiwiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCIsImNoZWNrUGFzc1N0eWxlIiwiY2hlY2tUYWdSZWNvcmQiLCJnZXRPd25EYXRhRGVzY3JpcHRvciIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IsXG5nZXRQcm90b3R5cGVPZixcbmhhc093blByb3BlcnR5Om9iamVjdEhhc093blByb3BlcnR5LFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcbmNvbnN0e2FwcGx5fT1SZWZsZWN0O1xuY29uc3R7dG9TdHJpbmdUYWc6dG9TdHJpbmdUYWdTeW1ib2x9PVN5bWJvbDtcblxuY29uc3QgdHlwZWRBcnJheVByb3RvdHlwZT1nZXRQcm90b3R5cGVPZihVaW50OEFycmF5LnByb3RvdHlwZSk7XG5jb25zdCB0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjPWdldE93blByb3BlcnR5RGVzY3JpcHRvcihcbnR5cGVkQXJyYXlQcm90b3R5cGUsXG50b1N0cmluZ1RhZ1N5bWJvbCk7XG5cbmFzc2VydCh0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjKTtcbmNvbnN0IGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZz10eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjLmdldDtcbmFzc2VydCh0eXBlb2YgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPT09J2Z1bmN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBoYXNPd25Qcm9wZXJ0eU9mPShvYmoscHJvcCk9PlxuYXBwbHkob2JqZWN0SGFzT3duUHJvcGVydHksb2JqLFtwcm9wXSk7JGjNj19vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbi8qIFRPRE8gdHJ5IHR5cGluZyB0aGlzOyBgPT4gdmFsIGlzIHt9IHRvbyBuYXJyb3csIGltcGxpZXMgbm8gcHJvcGVydGllcyovXG5jb25zdCAgICAgICAgaXNPYmplY3Q9KHZhbCk9Pk9iamVjdCh2YWwpPT09dmFsOyRozY9fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRozY9fb25jZS5pc1R5cGVkQXJyYXkoaXNUeXBlZEFycmF5KTtcbmhhcmRlbihpc1R5cGVkQXJyYXkpO1xuXG5jb25zdCAgICAgICAgUEFTU19TVFlMRT1TeW1ib2wuZm9yKCdwYXNzU3R5bGUnKTtcblxuLyoqXG4gKiBGb3IgYSBmdW5jdGlvbiB0byBiZSBhIHZhbGlkIG1ldGhvZCwgaXQgbXVzdCBub3QgYmUgcGFzc2FibGUuXG4gKiBPdGhlcndpc2UsIHdlIHJpc2sgY29uZnVzaW5nIHBhc3MtYnktY29weSBkYXRhIGNhcnJ5aW5nXG4gKiBmYXIgZnVuY3Rpb25zIHdpdGggYXR0ZW1wdHMgYXQgZmFyIG9iamVjdHMgd2l0aCBtZXRob2RzLlxuICpcbiAqIFRPRE8gSEFaQVJEIEJlY2F1c2Ugd2UgY2hlY2sgdGhpcyBvbiB0aGUgd2F5IHRvIGhhcmRlbmluZyBhIHJlbW90YWJsZSxcbiAqIHdlIGNhbm5vdCB5ZXQgY2hlY2sgdGhhdCBgZnVuY2AgaXMgaGFyZGVuZWQuIEhvd2V2ZXIsIHdpdGhvdXRcbiAqIGRvaW5nIHNvLCBpdCdzIGluaGVyaXRhbmNlIG1pZ2h0IGNoYW5nZSBhZnRlciB0aGUgYFBBU1NfU1RZTEVgXG4gKiBjaGVjayBiZWxvdy5cbiAqXG4gKiBAcGFyYW0ge2FueX0gZnVuY1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaM2PX29uY2UuUEFTU19TVFlMRShQQVNTX1NUWUxFKTtcbmNvbnN0ICAgICAgICBjYW5CZU1ldGhvZD0oZnVuYyk9PlxudHlwZW9mIGZ1bmM9PT0nZnVuY3Rpb24nJiYhKFBBU1NfU1RZTEUgaW4gZnVuYyk7JGjNj19vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjNj19vbmNlLmFzc2VydENoZWNrZXIoYXNzZXJ0Q2hlY2tlcik7XG5oYXJkZW4oYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogUmV0dXJucyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIGZ1bmN0aW9uIHRvIGZhaWwgdGhlIHByb3ZpZGVkIENoZWNrZXIgd2l0aCBkZXRhaWxzLlxuICogVGhlIG5hbWUgbXVzdCBiZSBzaG9ydCBmb3IgZXJnb25vbWljIGlubGluZSB1c2UgYXMgaW46XG4gKiBgYGBcbiAqIHJldHVybiBjaGVja0NvbmRpdGlvbiguLi4pIHx8ICghIWNoZWNrICYmIENYKGNoZWNrKWAuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY29uc3QgICAgICAgIENYPShjaGVjayk9PntcbmNvbnN0IHJlamVjdD0oVCwuLi5zdWJzKT0+Y2hlY2soZmFsc2UsWChULC4uLnN1YnMpKTtcbnJldHVybiByZWplY3Q7XG4gfTskaM2PX29uY2UuQ1goQ1gpO1xuaGFyZGVuKENYKTtcblxuLyoqXG4gKiBWZXJpZmllcyB0aGUgcHJlc2VuY2UgYW5kIGVudW1lcmFiaWxpdHkgb2YgYW4gb3duIGRhdGEgcHJvcGVydHlcbiAqIGFuZCByZXR1cm5zIGl0cyBkZXNjcmlwdG9yLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BOYW1lXG4gKiBAcGFyYW0ge2Jvb2xlYW59IHNob3VsZEJlRW51bWVyYWJsZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7UHJvcGVydHlEZXNjcmlwdG9yfVxuICovXG5jb25zdCAgICAgICAgZ2V0T3duRGF0YURlc2NyaXB0b3I9KFxuY2FuZGlkYXRlLFxucHJvcE5hbWUsXG5zaG91bGRCZUVudW1lcmFibGUsXG5jaGVjayk9Plxue1xuY29uc3QgZGVzYz0vKiogQHR5cGUge1Byb3BlcnR5RGVzY3JpcHRvcn0gKi9cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcihjYW5kaWRhdGUscHJvcE5hbWUpO1xuXG5yZXR1cm4oZGVzYyE9PXVuZGVmaW5lZHx8XG4hIWNoZWNrJiZDWChjaGVjaykgYCR7cShwcm9wTmFtZSl9IHByb3BlcnR5IGV4cGVjdGVkOiAke2NhbmRpZGF0ZX1gKSYmKFxuaGFzT3duUHJvcGVydHlPZihkZXNjLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gYWNjZXNzb3IgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWApJiYoXG5zaG91bGRCZUVudW1lcmFibGU/XG5kZXNjLmVudW1lcmFibGV8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGAke3EocHJvcE5hbWUpfSBtdXN0IGJlIGFuIGVudW1lcmFibGUgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWA6XG4hZGVzYy5lbnVtZXJhYmxlfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCk/XG5kZXNjOlxuLyoqIEB0eXBlIHtQcm9wZXJ0eURlc2NyaXB0b3J9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi91bmRlZmluZWQ7XG4gfTskaM2PX29uY2UuZ2V0T3duRGF0YURlc2NyaXB0b3IoZ2V0T3duRGF0YURlc2NyaXB0b3IpO1xuaGFyZGVuKGdldE93bkRhdGFEZXNjcmlwdG9yKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IFRcbiAqIEBwYXJhbSB7SU1QT1JUKCcuL3R5cGVzLmpzJykuUGFzc1N0eWxlZDxhbnksIFQ+fSB0YWdSZWNvcmRcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgZ2V0VGFnPSh0YWdSZWNvcmQpPT50YWdSZWNvcmRbU3ltYm9sLnRvU3RyaW5nVGFnXTskaM2PX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmoscGFzc1N0eWxlLGV4cGVjdGVkUGFzc1N0eWxlLGNoZWNrKT0+e1xucmV0dXJuKFxucGFzc1N0eWxlPT09ZXhwZWN0ZWRQYXNzU3R5bGV8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYEV4cGVjdGVkICR7cShleHBlY3RlZFBhc3NTdHlsZSl9LCBub3QgJHtxKHBhc3NTdHlsZSl9OiAke29ian1gKTtcblxuIH07JGjNj19vbmNlLmNoZWNrUGFzc1N0eWxlKGNoZWNrUGFzc1N0eWxlKTtcbmhhcmRlbihjaGVja1Bhc3NTdHlsZSk7XG5cbmNvbnN0IG1ha2VDaGVja1RhZ1JlY29yZD0oY2hlY2tQcm90byk9Pntcbi8qKlxuICogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVkPGFueSwgYW55Pn0gdGFnUmVjb3JkXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gZXhwZWN0ZWRQYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQsZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNPYmplY3QodGFnUmVjb3JkKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkmJihcbmlzRnJvemVuKHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBIHRhZ1JlY29yZCBtdXN0IGJlIGZyb3plbjogJHt0YWdSZWNvcmR9YCkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBbiBhcnJheSBjYW5ub3QgYmUgYSB0YWdSZWNvcmQ6ICR7dGFnUmVjb3JkfWApJiZcbmNoZWNrUGFzc1N0eWxlKFxudGFnUmVjb3JkLFxuZ2V0T3duRGF0YURlc2NyaXB0b3IodGFnUmVjb3JkLFBBU1NfU1RZTEUsZmFsc2UsY2hlY2spLnZhbHVlLFxuZXhwZWN0ZWRQYXNzU3R5bGUsXG5jaGVjaykmJihcblxudHlwZW9mIGdldE93bkRhdGFEZXNjcmlwdG9yKHRhZ1JlY29yZCxTeW1ib2wudG9TdHJpbmdUYWcsZmFsc2UsY2hlY2spLlxudmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkmJlxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaM2PX29uY2UuY2hlY2tUYWdSZWNvcmQoY2hlY2tUYWdSZWNvcmQpO1xuXG5oYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuXG5jb25zdCAgICAgICAgY2hlY2tGdW5jdGlvblRhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbnByb3RvIT09bnVsbCYmZ2V0UHJvdG90eXBlT2YocHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuISFjaGVjayYmXG5jaGVjayhcbmZhbHNlLFxuWCBgRm9yIGZ1bmN0aW9ucywgYSB0YWdSZWNvcmQgbXVzdCBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlOiAke3ZhbH1gKSk7JGjNj19vbmNlLmNoZWNrRnVuY3Rpb25UYWdSZWNvcmQoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG5cblxuaGFyZGVuKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJDWCI6WyJDWCJdLCJnZXRPd25EYXRhRGVzY3JpcHRvciI6WyJnZXRPd25EYXRhRGVzY3JpcHRvciJdLCJnZXRUYWciOlsiZ2V0VGFnIl0sImNoZWNrUGFzc1N0eWxlIjpbImNoZWNrUGFzc1N0eWxlIl0sImNoZWNrVGFnUmVjb3JkIjpbImNoZWNrVGFnUmVjb3JkIl0sImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiOlsiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZU9mLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vY29weUFycmF5LmpzIiwiLi9jb3B5UmVjb3JkLmpzIiwiLi90YWdnZWQuanMiLCIuL2Vycm9yLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3N5bWJvbC5qcyIsIi4vc2FmZS1wcm9taXNlLmpzIiwiLi9zdHJpbmcuanMiXSwiZXhwb3J0cyI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCIsImFzc2VydFBhc3NhYmxlIiwiaXNQYXNzYWJsZSIsInBhc3NTdHlsZU9mIiwidG9QYXNzYWJsZUVycm9yIiwidG9UaHJvd2FibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgaXNQcm9taXNlLFgsRmFpbCxxLGFubm90YXRlRXJyb3IsbWFrZUVycm9yLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYyxjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcixnZXRFcnJvckNvbnN0cnVjdG9yLGlzRXJyb3JMaWtlLFJlbW90YWJsZUhlbHBlcixhc3NlcnRQYXNzYWJsZVN5bWJvbCxhc3NlcnRTYWZlUHJvbWlzZSxhc3NlcnRQYXNzYWJsZVN0cmluZzskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJhbm5vdGF0ZUVycm9yXCIsIFskaM2PX2EgPT4gKGFubm90YXRlRXJyb3IgPSAkaM2PX2EpXV0sW1wibWFrZUVycm9yXCIsIFskaM2PX2EgPT4gKG1ha2VFcnJvciA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImlzVHlwZWRBcnJheVwiLCBbJGjNj19hID0+IChpc1R5cGVkQXJyYXkgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjNj19hID0+IChDb3B5QXJyYXlIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL2NvcHlSZWNvcmQuanNcIiwgW1tcIkNvcHlSZWNvcmRIZWxwZXJcIiwgWyRozY9fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRozY9fYSldXV1dLFtcIi4vdGFnZ2VkLmpzXCIsIFtbXCJUYWdnZWRIZWxwZXJcIiwgWyRozY9fYSA9PiAoVGFnZ2VkSGVscGVyID0gJGjNj19hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRozY9fYSA9PiAoRXJyb3JIZWxwZXIgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2NcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCIuL3NhZmUtcHJvbWlzZS5qc1wiLCBbW1wiYXNzZXJ0U2FmZVByb21pc2VcIiwgWyRozY9fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaM2PX2EpXV1dXSxbXCIuL3N0cmluZy5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTdHJpbmdcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTdHJpbmcgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGVIZWxwZXJ9IGZyb20gJy4vaW50ZXJuYWwtdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7Q29weUFycmF5LCBDb3B5UmVjb3JkLCBDb3B5VGFnZ2VkLCBQYXNzYWJsZX0gZnJvbSAnLi90eXBlcy5qcycgKi9cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UHJpbWl0aXZlU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbi8qKiBAdHlwZWRlZiB7RXhjbHVkZTxQYXNzU3R5bGUsIFByaW1pdGl2ZVN0eWxlIHwgXCJwcm9taXNlXCI+fSBIZWxwZXJQYXNzU3R5bGUgKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzRnJvemVuLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsdmFsdWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVyc1xuICogQHJldHVybnMge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIFBhc3NTdHlsZUhlbHBlcj4gfVxuICovXG5cbmNvbnN0IG1ha2VIZWxwZXJUYWJsZT0ocGFzc1N0eWxlSGVscGVycyk9Pntcbi8qKiBAdHlwZSB7UmVjb3JkPEhlbHBlclBhc3NTdHlsZSwgYW55PiAmIHtfX3Byb3RvX186IG51bGx9fSAqL1xuY29uc3QgSGVscGVyVGFibGU9e1xuX19wcm90b19fOm51bGwsXG5jb3B5QXJyYXk6dW5kZWZpbmVkLFxuY29weVJlY29yZDp1bmRlZmluZWQsXG50YWdnZWQ6dW5kZWZpbmVkLFxuZXJyb3I6dW5kZWZpbmVkLFxucmVtb3RhYmxlOnVuZGVmaW5lZH07XG5cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5jb25zdHtzdHlsZU5hbWV9PWhlbHBlcjtcbnN0eWxlTmFtZSBpbiBIZWxwZXJUYWJsZXx8RmFpbCBgVW5yZWNvZ25pemVkIGhlbHBlcjogJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09PT11bmRlZmluZWR8fFxuRmFpbCBgY29uZmxpY3RpbmcgaGVscGVycyBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09aGVscGVyO1xuIH1cbmZvcihjb25zdCBzdHlsZU5hbWUgb2Ygb3duS2V5cyhIZWxwZXJUYWJsZSkpe1xuSGVscGVyVGFibGVbc3R5bGVOYW1lXSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBtaXNzaW5nIGhlbHBlciBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbiB9XG5cbnJldHVybiBoYXJkZW4oSGVscGVyVGFibGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVycyBUaGUgcGFzc1N0eWxlSGVscGVycyB0byByZWdpc3RlcixcbiAqIGluIHByaW9yaXR5IG9yZGVyLlxuICogTk9URSBUaGVzZSBtdXN0IGFsbCBiZSBcInRydXN0ZWRcIixcbiAqIGNvbXBsZXRlLCBhbmQgbm9uLWNvbGxpZGluZy4gYG1ha2VQYXNzU3R5bGVPZmAgbWF5ICphc3N1bWUqIHRoYXQgZWFjaCBoZWxwZXJcbiAqIGRvZXMgd2hhdCBpdCBpcyBzdXBwb3NlZCB0byBkby4gYG1ha2VQYXNzU3R5bGVPZmAgaXMgbm90IHRyeWluZyB0byBkZWZlbmRcbiAqIGl0c2VsZiBhZ2FpbnN0IG1hbGljaW91cyBoZWxwZXJzLCB0aG91Z2ggaXQgZG9lcyBkZWZlbmQgYWdhaW5zdCBzb21lXG4gKiBhY2NpZGVudHMuXG4gKiBAcmV0dXJucyB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IG1ha2VQYXNzU3R5bGVPZj0ocGFzc1N0eWxlSGVscGVycyk9PntcbmNvbnN0IEhlbHBlclRhYmxlPW1ha2VIZWxwZXJUYWJsZShwYXNzU3R5bGVIZWxwZXJzKTtcbmNvbnN0IHJlbW90YWJsZUhlbHBlcj1IZWxwZXJUYWJsZS5yZW1vdGFibGU7XG5cbi8qKlxuICogUHVyZWx5IGZvciBwZXJmb3JtYW5jZS4gSG93ZXZlciBpdCBpcyBtdXRhYmxlIHN0YXRpYyBzdGF0ZSwgYW5kXG4gKiBpdCBkb2VzIGhhdmUgc29tZSBvYnNlcnZhYmlsaXR5IG9uIHByb3hpZXMuIFRPRE8gbmVlZCB0byBhc3Nlc3NcbiAqIHdoZXRoZXIgdGhpcyBjcmVhdGVzIGEgc3RhdGljIGNvbW11bmljYXRpb25zIGNoYW5uZWwuXG4gKlxuICogcGFzc1N0eWxlT2YgZG9lcyBhIGZ1bGwgcmVjdXJzaXZlIHdhbGsgb2YgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBpbiBvcmRlciB0byB2YWxpZGF0ZSB0aGF0IHRoZXkgYXJlIGFjeWNsaWMuIEluIGFkZGl0aW9uXG4gKiBpdCBpcyB1c2VkIGJ5IG90aGVyIGFsZ29yaXRobXMgdG8gcmVjdXJzaXZlbHkgd2FsayB0aGVzZSBwYXNzLWJ5LWNvcHlcbiAqIHN0cnVjdHVyZXMsIHNvIHdpdGhvdXQgdGhpcyBjYWNoZSwgdGhlc2UgYWxnb3JpdGhtcyBjb3VsZCBiZVxuICogTyhOKioyKSBvciB3b3JzZS5cbiAqXG4gKiBAdHlwZSB7V2Vha01hcDxXZWFrS2V5LCBQYXNzU3R5bGU+fVxuICovXG5jb25zdCBwYXNzU3R5bGVNZW1vPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZU9mfVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgcGFzc1N0eWxlT2Y9KHBhc3NhYmxlKT0+e1xuLyogRXZlbiB3aGVuIGEgV2Vha1NldCBpcyBjb3JyZWN0LCB3aGVuIHRoZSBzZXQgaGFzIGEgc2hvcnRlciBsaWZldGltZSovXG4vKiB0aGFuIGl0cyBrZXlzLCB3ZSBwcmVmZXIgYSBTZXQgZHVlIHRvIGV4cGVjdGVkIGltcGxlbWVudGF0aW9uKi9cbi8qIHRyYWRlb2Zmcy4qL1xuY29uc3QgaW5Qcm9ncmVzcz1uZXcgU2V0KCk7XG5cbmNvbnN0IHBhc3NTdHlsZU9mUmVjdXI9KGlubmVyKT0+e1xuY29uc3QgaW5uZXJJc09iamVjdD1pc09iamVjdChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbmNvbnN0IGlubmVyU3R5bGU9cGFzc1N0eWxlTWVtby5nZXQoaW5uZXIpO1xuaWYoaW5uZXJTdHlsZSl7XG5yZXR1cm4gaW5uZXJTdHlsZTtcbiB9XG4haW5Qcm9ncmVzcy5oYXMoaW5uZXIpfHxcbkZhaWwgYFBhc3MtYnktY29weSBkYXRhIGNhbm5vdCBiZSBjeWNsaWMgJHtpbm5lcn1gO1xuaW5Qcm9ncmVzcy5hZGQoaW5uZXIpO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2ZJbnRlcm5hbChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbnBhc3NTdHlsZU1lbW8uc2V0KGlubmVyLHBhc3NTdHlsZSk7XG5pblByb2dyZXNzLmRlbGV0ZShpbm5lcik7XG4gfVxucmV0dXJuIHBhc3NTdHlsZTtcbiB9O1xuXG5jb25zdCBwYXNzU3R5bGVPZkludGVybmFsPShpbm5lcik9PntcbmNvbnN0IHR5cGVzdHI9dHlwZW9mIGlubmVyO1xuc3dpdGNoKHR5cGVzdHIpe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzpcbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gdHlwZXN0cjtcbiB9XG5jYXNlJ3N0cmluZyc6e1xuYXNzZXJ0UGFzc2FibGVTdHJpbmcoaW5uZXIpO1xucmV0dXJuJ3N0cmluZyc7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKGlubmVyKTtcbnJldHVybidzeW1ib2wnO1xuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihpbm5lcj09PW51bGwpe1xucmV0dXJuJ251bGwnO1xuIH1cbmlmKCFpc0Zyb3plbihpbm5lcikpe1xuYXNzZXJ0LmZhaWwoXG4vKiBUeXBlZEFycmF5cyBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgaW4gaGFyZGVuKCkqL1xuLyogYW5kIGEgY29ycmVzcG9uZGluZyBzcGVjaWFsIGVycm9yIG1lc3NhZ2UgaGVyZS4qL1xuaXNUeXBlZEFycmF5KGlubmVyKT9cblggYENhbm5vdCBwYXNzIG11dGFibGUgdHlwZWQgYXJyYXlzIGxpa2UgJHtpbm5lcn0uYDpcblggYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgKTtcblxuIH1cbmlmKGlzUHJvbWlzZShpbm5lcikpe1xuYXNzZXJ0U2FmZVByb21pc2UoaW5uZXIpO1xucmV0dXJuJ3Byb21pc2UnO1xuIH1cbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xuY29uc3QgcGFzc1N0eWxlVGFnPWlubmVyW1BBU1NfU1RZTEVdO1xuaWYocGFzc1N0eWxlVGFnIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YocGFzc1N0eWxlVGFnLCdzdHJpbmcnKTtcbmNvbnN0IGhlbHBlcj1IZWxwZXJUYWJsZVtwYXNzU3R5bGVUYWddO1xuaGVscGVyIT09dW5kZWZpbmVkfHxcbkZhaWwgYFVucmVjb2duaXplZCBQYXNzU3R5bGU6ICR7cShwYXNzU3R5bGVUYWcpfWA7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc1N0eWxlfSAqL3Bhc3NTdHlsZVRhZyk7XG4gfVxuZm9yKGNvbnN0IGhlbHBlciBvZiBwYXNzU3R5bGVIZWxwZXJzKXtcbmlmKGhlbHBlci5jYW5CZVZhbGlkKGlubmVyKSl7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gaGVscGVyLnN0eWxlTmFtZTtcbiB9XG4gfVxucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuY2FzZSdmdW5jdGlvbic6e1xuaXNGcm96ZW4oaW5uZXIpfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgO1xudHlwZW9mIGlubmVyLnRoZW4hPT0nZnVuY3Rpb24nfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1wcm9taXNlIHRoZW5hYmxlc2A7XG5yZW1vdGFibGVIZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4ncmVtb3RhYmxlJztcbiB9XG5kZWZhdWx0OntcbnRocm93IGFzc2VydC5mYWlsKFggYFVucmVjb2duaXplZCB0eXBlb2YgJHtxKHR5cGVzdHIpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTtcblxucmV0dXJuIHBhc3NTdHlsZU9mUmVjdXIocGFzc2FibGUpO1xuIH07XG5yZXR1cm4gaGFyZGVuKHBhc3NTdHlsZU9mKTtcbiB9O1xuXG5jb25zdCAgICAgICAgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2w9U3ltYm9sLmZvcignQGVuZG8gcGFzc1N0eWxlT2YnKTtcblxuLyoqXG4gKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2wgcHJvcGVydHkgb24gdGhlIGdsb2JhbCxcbiAqIHRoZW4gcHJlc3VtYWJseSBpdCB3YXMgZW5kb3dlZCBmb3IgdXMgYnkgbGl2ZXNsb3RzIHdpdGggYSBgcGFzc1N0eWxlT2ZgXG4gKiBmdW5jdGlvbiwgc28gd2Ugc2hvdWxkIHVzZSBhbmQgZXhwb3J0IHRoYXQgb25lIGluc3RlYWQuXG4gKiBPdGhlciBzb2Z0d2FyZSBtYXkgaGF2ZSBsZWZ0IGl0IGZvciB1cyBoZXJlLFxuICogYnV0IGl0IHdvdWxkIHJlcXVpcmUgd3JpdGUgYWNjZXNzIHRvIG91ciBnbG9iYWwsIG9yIHRoZSBhYmlsaXR5IHRvXG4gKiBwcm92aWRlIGVuZG93bWVudHMgdG8gb3VyIGdsb2JhbCwgYm90aCBvZiB3aGljaCBzZWVtcyBhZGVxdWF0ZSBhcyBhIHRlc3Qgb2ZcbiAqIHdoZXRoZXIgaXQgaXMgYXV0aG9yaXplZCB0byBzZXJ2ZSB0aGUgc2FtZSByb2xlIGFzIGxpdmVzbG90cy5cbiAqXG4gKiBOT1RFIEhBWkFSRDogVGhpcyB1c2UgYnkgbGl2ZXNsb3RzIGRvZXMgcmVseSBvbiBgcGFzc1N0eWxlT2ZgIGJlaW5nXG4gKiBkZXRlcm1pbmlzdGljLiBJZiBpdCBpcyBub3QsIHRoZW4gaW4gYSBsaXZlc2xvdC1saWtlIHZpcnR1YWxpemVkXG4gKiBlbnZpcm9ubWVudCwgaXQgY2FuIGJlIHVzZWQgdG8gZGV0ZWN0IEdDLlxuICpcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqLyRozY9fb25jZS5QYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbChQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCk7XG5jb25zdCAgICAgICAgcGFzc1N0eWxlT2Y9XG5nbG9iYWxUaGlzJiZnbG9iYWxUaGlzW1Bhc3NTdHlsZU9mRW5kb3dtZW50U3ltYm9sXXx8XG5tYWtlUGFzc1N0eWxlT2YoW1xuQ29weUFycmF5SGVscGVyLFxuQ29weVJlY29yZEhlbHBlcixcblRhZ2dlZEhlbHBlcixcbkVycm9ySGVscGVyLFxuUmVtb3RhYmxlSGVscGVyXSk7JGjNj19vbmNlLnBhc3NTdHlsZU9mKHBhc3NTdHlsZU9mKTtcblxuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGU9KHZhbCk9PntcbnBhc3NTdHlsZU9mKHZhbCk7LyogdGhyb3dzIGlmIHZhbCBpcyBub3QgYSBwYXNzYWJsZSovXG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcblxuLyoqXG4gKiBJcyBgc3BlY2ltZW5gIFBhc3NhYmxlPyBUaGlzIHJldHVybnMgdHJ1ZSBpZmYgYHBhc3NTdHlsZU9mKHNwZWNpbWVuKWBcbiAqIHJldHVybnMgYSBzdHJpbmcuIFRoaXMgcmV0dXJucyBgZmFsc2VgIGlmZiBgcGFzc1N0eWxlT2Yoc3BlY2ltZW4pYCB0aHJvd3MuXG4gKiBVbmRlciBubyBub3JtYWwgY2lyY3Vtc3RhbmNlIHNob3VsZCBgaXNQYXNzYWJsZShzcGVjaW1lbilgIHRocm93LlxuICpcbiAqIFRPRE8gRGVwcmVjYXRlIGFuZCB1bHRpbWF0ZWx5IGRlbGV0ZSBAYWdvcmljL2Jhc2Utem9uZSdzIGBpc1Bhc3NhYmxlJyBpblxuICogZmF2b3Igb2YgdGhpcyBvbmUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8yMDk2XG4gKlxuICogVE9ETyBpbXBsZW1lbnQgYW4gaXNQYXNzYWJsZSB0aGF0IGRvZXMgbm90IHJlbHkgb24gdHJ5L2NhdGNoLlxuICogVGhpcyBpbXBsZW1lbnRhdGlvbiBpcyBqdXN0IGEgc3RhbmRpbiB1bnRpbCB0aGVuLlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMjA5NlxuICpcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHJldHVybnMge3NwZWNpbWVuIGlzIFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgaXNQYXNzYWJsZT0oc3BlY2ltZW4pPT57XG50cnl7XG4vKiBJbiBmYWN0LCBpdCBuZXZlciByZXR1cm5zIHVuZGVmaW5lZC4gSXQgZWl0aGVyIHJldHVybnMgYSovXG4vKiBzdHJpbmcgb3IgdGhyb3dzLiovXG5yZXR1cm4gcGFzc1N0eWxlT2Yoc3BlY2ltZW4pIT09dW5kZWZpbmVkO1xuIH1jYXRjaChfKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfTskaM2PX29uY2UuaXNQYXNzYWJsZShpc1Bhc3NhYmxlKTtcbmhhcmRlbihpc1Bhc3NhYmxlKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc1Bhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2M9KG5hbWUsZGVzYyk9PlxuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MobmFtZSxkZXNjLHBhc3NTdHlsZU9mKTtcblxuLyoqXG4gKiBBZnRlciBoYXJkZW5pbmcsIGlmIGBlcnJgIGlzIGEgcGFzc2FibGUgZXJyb3IsIHJldHVybiBpdC5cbiAqXG4gKiBPdGhlcndpc2UsIHJldHVybiBhIG5ldyBwYXNzYWJsZSBlcnJvciB0aGF0IHByb3BhZ2F0ZXMgdGhlIGRpYWdub3N0aWNcbiAqIGluZm8gb2YgdGhlIG9yaWdpbmFsLCBhbmQgaXMgbGlua2VkIHRvIHRoZSBvcmlnaW5hbCBhcyBhIG5vdGUuXG4gKlxuICogVE9ETyBBZG9wdCBhIG1vcmUgZmxleGlibGUgbm90aW9uIG9mIHBhc3NhYmxlIGVycm9yLCBpbiB3aGljaFxuICogYSBwYXNzYWJsZSBlcnJvciBjYW4gY29udGFpbiBvdGhlciBvd24gZGF0YSBwcm9wZXJ0aWVzIHdpdGhcbiAqIHRocm93YWJsZSB2YWx1ZXMuXG4gKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0ICAgICAgICB0b1Bhc3NhYmxlRXJyb3I9KGVycik9PntcbmhhcmRlbihlcnIpO1xuaWYoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mKSl7XG5yZXR1cm4gZXJyO1xuIH1cbmNvbnN0e25hbWUsbWVzc2FnZX09ZXJyO1xuY29uc3R7Y2F1c2U6Y2F1c2VEZXNjLGVycm9yczplcnJvcnNEZXNjfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoZXJyKTtcbmxldCBjYXVzZTtcbmxldCBlcnJvcnM7XG5pZihjYXVzZURlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnY2F1c2UnLGNhdXNlRGVzYykpe1xuY2F1c2U9Y2F1c2VEZXNjLnZhbHVlO1xuIH1cbmlmKGVycm9yc0Rlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnZXJyb3JzJyxlcnJvcnNEZXNjKSl7XG5lcnJvcnM9ZXJyb3JzRGVzYy52YWx1ZTtcbiB9XG5cbmNvbnN0IGVyckNvbnN0cnVjdG9yPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9bWFrZUVycm9yKCBgJHttZXNzYWdlfWAsZXJyQ29uc3RydWN0b3Ise1xuLyogQHRzLWlnbm9yZSBBc3N1bWluZyBjYXVzZSBpcyBFcnJvciB8IHVuZGVmaW5lZCovXG5jYXVzZSxcbmVycm9yc30pO1xuXG4vKiBTdGlsbCBuZWVkZWQsIGJlY2F1c2UgYG1ha2VFcnJvcmAgb25seSBkb2VzIGEgc2hhbGxvdyBmcmVlemUuKi9cbmhhcmRlbihuZXdFcnJvcik7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hbm5vdGF0ZUVycm9yKG5ld0Vycm9yLFggYGNvcGllZCBmcm9tIGVycm9yICR7ZXJyfWApO1xucGFzc1N0eWxlT2YobmV3RXJyb3IpPT09J2Vycm9yJ3x8XG5GYWlsIGBFeHBlY3RlZCAke25ld0Vycm9yfSB0byBiZSBhIHBhc3NhYmxlIGVycm9yYDtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRozY9fb25jZS50b1Bhc3NhYmxlRXJyb3IodG9QYXNzYWJsZUVycm9yKTtcbmhhcmRlbih0b1Bhc3NhYmxlRXJyb3IpO1xuXG4vKipcbiAqIEFmdGVyIGhhcmRlbmluZywgaWYgYHNwZWNpbWVuYCBpcyB0aHJvd2FibGUsIHJldHVybiBpdC5cbiAqIEEgc3BlY2ltZW4gaXMgdGhyb3dhYmxlIGlmZiBpdCBpcyBQYXNzYWJsZSBhbmQgY29udGFpbnMgbm8gUGFzc2FibGVDYXBzLFxuICogaS5lLiwgbm8gUmVtb3RhYmxlcyBvciBQcm9taXNlcy5cbiAqIElPVywgaWYgaXQgY29udGFpbnMgb25seSBjb3B5LWRhdGEgYW5kIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBPdGhlcndpc2UsIGlmIGBzcGVjaW1lbmAgaXMgKmFsbW9zdCogdGhyb3dhYmxlLCBmb3IgZXhhbXBsZSwgaXQgaXNcbiAqIGFuIGVycm9yIHRoYXQgY2FuIGJlIG1hZGUgdGhyb3dhYmxlIGJ5IGB0b1Bhc3NhYmxlRXJyb3JgLCB0aGVuXG4gKiByZXR1cm4gYHNwZWNpbWVuYCBjb252ZXJ0ZWQgdG8gYSB0aHJvd2FibGUuXG4gKlxuICogT3RoZXJ3aXNlLCB0aHJvdyBhIGRpYWdub3N0aWMgaW5kaWNhdGluZyBhIGZhaWx1cmUgdG8gY29lcmNlLlxuICpcbiAqIFRoaXMgaXMgaW4gc3VwcG9ydCBvZiB0aGUgZXhvIGJvdW5kYXJ5IHRocm93aW5nIG9ubHkgdGhyb3dhYmxlcywgdG8gZWFzZVxuICogc2VjdXJpdHkgcmV2aWV3LlxuICpcbiAqIFRPRE8gQWRvcHQgYSBtb3JlIGZsZXhpdGJsZSBub3Rpb24gb2YgdGhyb3dhYmxlLCBpbiB3aGljaFxuICogZGF0YSBjb250YWluZXJzIGNvbnRhaW5pbmcgbm9uLXBhc3NhYmxlIGVycm9ycyBjYW4gdGhlbXNlbHZlcyBiZSBjb2VyY2VkXG4gKiB0byB0aHJvd2FibGUgYnkgY29lcmNpbmcgdG8gYSBzaW1pbGFyIGNvbnRhaW5lcnMgY29udGFpbmluZ1xuICogdGhlIHJlc3VsdHMgb2YgY29lcmNpbmcgdGhvc2UgZXJyb3JzIHRvIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHNwZWNpbWVuXG4gKiBAcmV0dXJucyB7UGFzc2FibGU8bmV2ZXIsIEVycm9yPn1cbiAqL1xuY29uc3QgICAgICAgIHRvVGhyb3dhYmxlPShzcGVjaW1lbik9PntcbmhhcmRlbihzcGVjaW1lbik7XG5pZihpc0Vycm9yTGlrZShzcGVjaW1lbikpe1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcigvKiogQHR5cGUge0Vycm9yfSAqL3NwZWNpbWVuKTtcbiB9XG4vKiBOb3RlIHRoYXQgdGhpcyBzdGVwIHdpbGwgZmFpbCBpZiBgc3BlY2ltZW5gIHdvdWxkIGJlIGEgcGFzc2FibGUgY29udGFpbmVyKi9cbi8qIGV4Y2VwdCB0aGF0IGl0IGNvbnRhaW5zIG5vbi1wYXNzYWJsZSBlcnJvcnMgdGhhdCBjb3VsZCBiZSBjb252ZXJ0ZWQuKi9cbi8qIFRoaXMgd2lsbCBuZWVkIHRvIGJlIGZpeGVkIHRvIGRvIHRoZSBUT0RPIGFib3ZlLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2Yoc3BlY2ltZW4pO1xuaWYoaXNPYmplY3Qoc3BlY2ltZW4pKXtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5QXJyYXknOntcbmNvbnN0IGVsZW1lbnRzPS8qKiBAdHlwZSB7Q29weUFycmF5fSAqL3NwZWNpbWVuO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgZWxlbWVudHMpe1xuZWxlbWVudD09PXRvVGhyb3dhYmxlKGVsZW1lbnQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke2VsZW1lbnR9YDtcbiB9XG5icmVhaztcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmNvbnN0IHJlYz0vKiogQHR5cGUge0NvcHlSZWNvcmR9ICovc3BlY2ltZW47XG5mb3IoY29uc3QgdmFsIG9mIHZhbHVlcyhyZWMpKXtcbnZhbD09PXRvVGhyb3dhYmxlKHZhbCl8fFxuRmFpbCBgbmVzdGVkIHRvVGhyb3dhYmxlIGNvZXJjaW9uIG5vdCB5ZXQgc3VwcG9ydGVkICR7dmFsfWA7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRnPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi9zcGVjaW1lbjtcbmNvbnN0e3BheWxvYWR9PXRnO1xucGF5bG9hZD09PXRvVGhyb3dhYmxlKHBheWxvYWQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke3BheWxvYWR9YDtcbmJyZWFrO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVyPS8qKiBAdHlwZSB7RXJyb3J9ICovc3BlY2ltZW47XG5lcj09PXRvVGhyb3dhYmxlKGVyKXx8XG5GYWlsIGBuZXN0ZWQgdG9UaHJvd2FibGUgY29lcmNpb24gbm90IHlldCBzdXBwb3J0ZWQgJHtlcn1gO1xuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBBICR7cShwYXNzU3R5bGUpfSBpcyBub3QgdGhyb3dhYmxlOiAke3NwZWNpbWVufWA7XG4gfX1cblxuIH1cbnJldHVybiAoLyoqIEB0eXBlIHtQYXNzYWJsZTxuZXZlcixuZXZlcj59ICovc3BlY2ltZW4pO1xuIH07JGjNj19vbmNlLnRvVGhyb3dhYmxlKHRvVGhyb3dhYmxlKTtcbmhhcmRlbih0b1Rocm93YWJsZSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCJdLCJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdLCJpc1Bhc3NhYmxlIjpbImlzUGFzc2FibGUiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdLCJ0b1Rocm93YWJsZSI6WyJ0b1Rocm93YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACC5ALHEiIAABIiAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEsYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxoYXNPd25Qcm9wZXJ0eU9mLFBBU1NfU1RZTEUsY2hlY2tUYWdSZWNvcmQsY2hlY2tGdW5jdGlvblRhZ1JlY29yZCxpc09iamVjdCxnZXRUYWcsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjNj19hID0+IChjaGVja1RhZ1JlY29yZCA9ICRozY9fYSldXSxbXCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQgPSAkaM2PX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRozY9fYSA9PiAoaXNPYmplY3QgPSAkaM2PX2EpXV0sW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDaGVja2VyfSBmcm9tICcuL3R5cGVzLmpzJ1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlYywgUGFzc1N0eWxlZH0gZnJvbSAnLi90eXBlcy5qcydcbiAqIEBpbXBvcnQge1Bhc3NTdHlsZUhlbHBlcn0gZnJvbSAnLi9pbnRlcm5hbC10eXBlcy5qcydcbiAqIEBpbXBvcnQge1JlbW90YWJsZU9iamVjdCBhcyBSZW1vdGFibGV9IGZyb20gJy4vdHlwZXMuanMnXG4gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZSxcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICovXG5jb25zdCBjaGVja0lmYWNlPShpZmFjZSxjaGVjayk9PntcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRm9yIG5vdywgaW50ZXJmYWNlICR7aWZhY2V9IG11c3QgYmUgYSBzdHJpbmc7IHVuaW1wbGVtZW50ZWRgKSYmKFxuaWZhY2U9PT0nUmVtb3RhYmxlJ3x8XG5pZmFjZS5zdGFydHNXaXRoKCdBbGxlZ2VkOiAnKXx8XG5pZmFjZS5zdGFydHNXaXRoKCdEZWJ1Z05hbWU6ICcpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGb3Igbm93LCBpZmFjZSAke3EoXG5pZmFjZSlcbiB9IG11c3QgYmUgXCJSZW1vdGFibGVcIiBvciBiZWdpbiB3aXRoIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiOyB1bmltcGxlbWVudGVkYCkpO1xuXG4gfTtcblxuLyoqXG4gKiBBbiBgaWZhY2VgIG11c3QgYmUgcHVyZS4gUmlnaHQgbm93IGl0IG11c3QgYmUgYSBzdHJpbmcsIHdoaWNoIGlzIHB1cmUuXG4gKiBMYXRlciB3ZSBleHBlY3QgdG8gaW5jbHVkZSBzb21lIG90aGVyIHZhbHVlcyB0aGF0IHF1YWxpZnkgYXMgYFB1cmVEYXRhYCxcbiAqIHdoaWNoIGlzIGEgcGFzcy1ieS1jb3B5IHN1cGVyc3RydWN0dXJlIGVuZGluZyBvbmx5IGluIHByaW1pdGl2ZXMgb3JcbiAqIGVtcHR5IHBhc3MtYnktY29weSBjb21wb3NpdGVzLiBObyByZW1vdGFibGVzLCBwcm9taXNlcywgb3IgZXJyb3JzLlxuICogV2UgKmFzc3VtZSogZm9yIG5vdyB0aGF0IHRoZSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgY29udGFpbnMgbm9cbiAqIHByb3hpZXMuXG4gKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0SWZhY2U9KGlmYWNlKT0+Y2hlY2tJZmFjZShpZmFjZSxhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmlzT2JqZWN0KG9yaWdpbmFsKXx8XG5GYWlsIGBSZW1vdGFibGVzIG11c3QgYmUgb2JqZWN0cyBvciBmdW5jdGlvbnM6ICR7b3JpZ2luYWx9YDtcblxuLyogQSB2YWxpZCByZW1vdGFibGUgb2JqZWN0IG11c3QgaW5oZXJpdCBmcm9tIGEgXCJ0YWcgcmVjb3JkXCIgLS0gYSovXG4vKiBwbGFpbi1vYmplY3QgcHJvdG90eXBlIGNvbnNpc3Rpbmcgb2Ygb25seSovXG4vKiBhIGBQQVNTX1NUWUxFYCBwcm9wZXJ0eSB3aXRoIHZhbHVlIFwicmVtb3RhYmxlXCIgYW5kIGEgc3VpdGFibGUgYFN5bWJvbC50b1N0cmluZ1RhZ2AqL1xuLyogcHJvcGVydHkuIFRoZSByZW1vdGFibGUgY291bGQgaW5oZXJpdCBkaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLCBvciovXG4vKiBpdCBjb3VsZCBpbmhlcml0IGZyb20gYW5vdGhlciB2YWxpZCByZW1vdGFibGUsIHRoYXQgdGhlcmVmb3JlIGl0c2VsZiovXG4vKiBpbmhlcml0cyBkaXJlY3RseSBvciBpbmRpcmVjdGx5IGZyb20gc3VjaCBhIHRhZyByZWNvcmQuKi9cbi8qKi9cbi8qIFRPRE86IEl0IHdvdWxkIGJlIG5pY2UgdG8gdHlwZWRlZiB0aGlzIHNoYXBlLCBidXQgd2UgY2FuJ3QgZGVjbGFyZSBhIHR5cGUqL1xuLyogd2l0aCBQQVNTX1NUWUxFIGZyb20gSlNEb2MuKi9cbi8qKi9cbi8qIEB0eXBlIHt7IFtQQVNTX1NUWUxFXTogc3RyaW5nLCovXG4vKiBbU3ltYm9sLnRvU3RyaW5nVGFnXTogc3RyaW5nLCovXG4vKiB9fSovXG4vKiovXG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihvcmlnaW5hbCk7XG5pZihcbnByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbnByb3RvPT09bnVsbHx8XG5wcm90bz09PUZ1bmN0aW9uLnByb3RvdHlwZSlcbntcbnJldHVybihcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZW1vdGFibGVzIG11c3QgYmUgZXhwbGljaXRseSBkZWNsYXJlZDogJHtxKG9yaWdpbmFsKX1gKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gUmVtb3RhYmxlIFByb3RvICR7b3duS2V5cyhyZXN0RGVzY3MpfWApJiZcbmNoZWNrSWZhY2UoaWZhY2UsY2hlY2spKTtcblxuIH07XG5cbi8qKlxuICogS2VlcCBhIHdlYWsgc2V0IG9mIGNvbmZpcm1lZCByZW1vdGFibGVzIGZvciBtYXJzaGFsIHBlcmZvcm1hbmNlXG4gKiAod2l0aG91dCB3aGljaCB3ZSB3b3VsZCBpbmN1ciBhIHJlZHVuZGFudCB2ZXJpZmljYXRpb24gaW5cbiAqIGdldEludGVyZmFjZU9mKS5cbiAqIFdlIGRvbid0IHJlbWVtYmVyIHJlamVjdGlvbnMgYmVjYXVzZSB0aGV5IGFyZSBwb3NzaWJsZSB0byBjb3JyZWN0XG4gKiB3aXRoIGUuZy4gYGhhcmRlbmAuXG4gKlxuICogQHR5cGUge1dlYWtTZXQ8UmVtb3RhYmxlPn1cbiAqL1xuY29uc3QgY29uZmlybWVkUmVtb3RhYmxlcz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge3ZhbCBpcyBSZW1vdGFibGV9XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlPSh2YWwsY2hlY2spPT57XG5pZihjb25maXJtZWRSZW1vdGFibGVzLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybihcbiEhY2hlY2smJkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke3ZhbH1gKTtcblxuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIFNpbXBsZSBzZW1hbnRpY3MsIGp1c3QgdGVsbCB3aGF0IGludGVyZmFjZSBzcGVjIGEgUmVtb3RhYmxlIGhhcyxcbiAqIG9yIHVuZGVmaW5lZCBpZiBub3QgZGVlbWVkIHRvIGJlIGEgUmVtb3RhYmxlLlxuICpcbiAqIEB0eXBlIHt7XG4gKiA8VCBleHRlbmRzIHN0cmluZz4odmFsOiBQYXNzU3R5bGVkPGFueSwgVD4pOiBUO1xuICogKHZhbDogYW55KTogSW50ZXJmYWNlU3BlYyB8IHVuZGVmaW5lZDtcbiAqIH19XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbi8qIEB0cy1leHBlY3QtZXJyb3IgbmFycm93ZWQqL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5hcnJvd2VkKi9cbnJldHVybiBnZXRUYWcodmFsKTtcbiB9OyRozY9fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCB2YWxpZFR5cGU9XG4oaXNPYmplY3QoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tb2JqZWN0cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgYXJyYXlzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKTtcbmlmKCF2YWxpZFR5cGUpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xuaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdvYmplY3QnKXtcbi8qIEV2ZXJ5IG93biBwcm9wZXJ0eSAocmVnYXJkbGVzcyBvZiBlbnVtZXJhYmlsaXR5KSovXG4vKiBtdXN0IGhhdmUgYSBmdW5jdGlvbiB2YWx1ZS4qL1xucmV0dXJuIG93bktleXMoZGVzY3MpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4vKiBUeXBlY2FzdCBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG4oaGFzT3duUHJvcGVydHlPZihkZXNjc1svKiogQHR5cGUge3N0cmluZ30gKi9rZXldLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBjYW5ub3Qgc2VyaWFsaXplIFJlbW90YWJsZXMgd2l0aCBhY2Nlc3NvcnMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApJiYoXG5rZXk9PT1TeW1ib2wudG9TdHJpbmdUYWcmJmNoZWNrSWZhY2UoY2FuZGlkYXRlW2tleV0sY2hlY2spfHxcbihjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIG5vbi1tZXRob2RzIGxpa2UgJHtxKFxuU3RyaW5nKGtleSkpXG4gfSBpbiAke2NhbmRpZGF0ZX1gKSYmKFxua2V5IT09UEFTU19TVFlMRXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpO1xuXG4gfSk7XG4gfWVsc2UgaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdmdW5jdGlvbicpe1xuLyogRmFyIGZ1bmN0aW9ucyBjYW5ub3QgYmUgbWV0aG9kcywgYW5kIGNhbm5vdCBoYXZlIG1ldGhvZHMuKi9cbi8qIFRoZXkgbXVzdCBoYXZlIGV4YWN0bHkgZXhwZWN0ZWQgYC5uYW1lYCBhbmQgYC5sZW5ndGhgIHByb3BlcnRpZXMqL1xuY29uc3R7XG5uYW1lOm5hbWVEZXNjLFxubGVuZ3RoOmxlbmd0aERlc2MsXG4vKiBAdHMtaWdub3JlIFRTIGRvZXNuJ3QgbGlrZSBzeW1ib2xzIGFzIGNvbXB1dGVkIGluZGV4ZXM/PyovXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp0b1N0cmluZ1RhZ0Rlc2MsXG4uLi5yZXN0RGVzY3N9PVxuZGVzY3M7XG5jb25zdCByZXN0S2V5cz1vd25LZXlzKHJlc3REZXNjcyk7XG5yZXR1cm4oXG4obmFtZURlc2MmJnR5cGVvZiBuYW1lRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGYXIgZnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbiBsZW5ndGggbXVzdCBiZSBhIG51bWJlciwgaW4gJHtjYW5kaWRhdGV9YCkmJihcbnRvU3RyaW5nVGFnRGVzYz09PXVuZGVmaW5lZHx8XG4odHlwZW9mIHRvU3RyaW5nVGFnRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRmFyIGZ1bmN0aW9uIEBAdG9TdHJpbmdUYWcgbXVzdCBiZSBhIHN0cmluZywgaW4gJHtjYW5kaWRhdGV9YCkmJlxuY2hlY2tJZmFjZSh0b1N0cmluZ1RhZ0Rlc2MudmFsdWUsY2hlY2spKSYmKFxucmVzdEtleXMubGVuZ3RoPT09MHx8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSk7XG5cbiB9XG5yZXR1cm4hIWNoZWNrJiZDWChjaGVjaykgYHVucmVjb2duaXplZCB0eXBlb2YgJHtjYW5kaWRhdGV9YDtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaM2PX29uY2UuUmVtb3RhYmxlSGVscGVyKFJlbW90YWJsZUhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJZmFjZSI6WyJhc3NlcnRJZmFjZSJdLCJnZXRJbnRlcmZhY2VPZiI6WyJnZXRJbnRlcmZhY2VPZiJdLCJSZW1vdGFibGVIZWxwZXIiOlsiUmVtb3RhYmxlSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAARGFca6FAAAuhQAACsAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbImFzc2VydFNhZmVQcm9taXNlIiwiaXNTYWZlUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBpc1Byb21pc2UscSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2YsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wiaXNQcm9taXNlXCIsIFskaM2PX2EgPT4gKGlzUHJvbWlzZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge0NoZWNrZXJ9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2lzRnJvemVuLGdldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e3RvU3RyaW5nVGFnfT1TeW1ib2w7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCBrZXlzPW93bktleXMocHIpO1xuXG5pZihrZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG4vKipcbiAqIFRoaXMgZXhjbHVkZXMgdGhvc2Ugc3ltYm9sLW5hbWVkIG93biBwcm9wZXJ0aWVzIHRoYXQgYXJlIGFsc28gZm91bmQgb25cbiAqIGBQcm9taXNlLnByb3RvdHlwZWAsIHNvIHRoYXQgb3ZlcnJpZGVzIG9mIHRoZXNlIHByb3BlcnRpZXMgY2FuIGJlXG4gKiBleHBsaWNpdGx5IHRvbGVyYXRlZCBpZiB0aGV5IHBhc3MgdGhlIGBjaGVja1NhZmVPd25LZXlgIGNoZWNrIGJlbG93LlxuICogSW4gcGFydGljdWxhciwgd2Ugd2lzaCB0byB0b2xlcmF0ZVxuICogICAqIEFuIG92ZXJyaWRpbmcgYHRvU3RyaW5nVGFnYCBub24tZW51bWVyYWJsZSBkYXRhIHByb3BlcnR5XG4gKiAgICAgd2l0aCBhIHN0cmluZyB2YWx1ZS5cbiAqICAgKiBUaG9zZSBvd24gcHJvcGVydGllcyB0aGF0IG1pZ2h0IGJlIGFkZGVkIGJ5IE5vZGUncyBhc3luY19ob29rcy5cbiAqL1xuY29uc3QgdW5rbm93bktleXM9a2V5cy5maWx0ZXIoXG4oa2V5KT0+dHlwZW9mIGtleSE9PSdzeW1ib2wnfHwhaGFzT3duUHJvcGVydHlPZihQcm9taXNlLnByb3RvdHlwZSxrZXkpKTtcblxuXG5pZih1bmtub3duS2V5cy5sZW5ndGghPT0wKXtcbnJldHVybiBDWChcbmNoZWNrKVxuIGAke3ByfSAtIE11c3Qgbm90IGhhdmUgYW55IG93biBwcm9wZXJ0aWVzOiAke3EodW5rbm93bktleXMpfWA7XG4gfVxuXG4vKipcbiAqIEV4cGxpY2l0bHkgdG9sZXJhdGUgYSBgdG9TdHJpbmdUYWdgIHN5bWJvbC1uYW1lZCBub24tZW51bWVyYWJsZVxuICogZGF0YSBwcm9wZXJ0eSB3aG9zZSB2YWx1ZSBpcyBhIHN0cmluZy4gT3RoZXJ3aXNlLCB0b2xlcmF0ZSB0aG9zZVxuICogc3ltYm9sLW5hbWVkIHByb3BlcnRpZXMgdGhhdCBtaWdodCBiZSBhZGRlZCBieSBOb2RlSlMncyBhc3luY19ob29rcyxcbiAqIGlmIHRoZXkgb2JleSB0aGUgZXhwZWN0ZWQgc2FmZXR5IHByb3BlcnRpZXMuXG4gKlxuICogQXQgdGhlIHRpbWUgb2YgdGhpcyB3cml0aW5nLCBOb2RlJ3MgYXN5bmNfaG9va3MgY29udGFpbnMgdGhlXG4gKiBmb2xsb3dpbmcgY29kZSwgd2hpY2ggd2UgY2FuIHNhZmVseSB0b2xlcmF0ZVxuICpcbiAqIGBgYGpzXG4gKiBmdW5jdGlvbiBkZXN0cm95VHJhY2tpbmcocHJvbWlzZSwgcGFyZW50KSB7XG4gKiAgIHRyYWNrUHJvbWlzZShwcm9taXNlLCBwYXJlbnQpO1xuICogICBjb25zdCBhc3luY0lkID0gcHJvbWlzZVthc3luY19pZF9zeW1ib2xdO1xuICogICBjb25zdCBkZXN0cm95ZWQgPSB7IGRlc3Ryb3llZDogZmFsc2UgfTtcbiAqICAgcHJvbWlzZVtkZXN0cm95ZWRTeW1ib2xdID0gZGVzdHJveWVkO1xuICogICByZWdpc3RlckRlc3Ryb3lIb29rKHByb21pc2UsIGFzeW5jSWQsIGRlc3Ryb3llZCk7XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGtleVxuICovXG5jb25zdCBjaGVja1NhZmVPd25LZXk9KGtleSk9PntcbmlmKGtleT09PXRvU3RyaW5nVGFnKXtcbi8qIFRPRE8gc2hvdWxkIHdlIGFsc28gZW5mb3JjZSBhbnl0aGluZyBvbiB0aGUgY29udGVudHMgb2YgdGhlIHN0cmluZywqL1xuLyogc3VjaCBhcyB0aGF0IGl0IG11c3Qgc3RhcnQgd2l0aCBgJ1Byb21pc2UnYD8qL1xuY29uc3QgdGFnRGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IocHIsdG9TdHJpbmdUYWcpO1xuYXNzZXJ0KHRhZ0Rlc2MhPT11bmRlZmluZWQpO1xucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YodGFnRGVzYywndmFsdWUnKXx8XG5DWChcbmNoZWNrKVxuIGBPd24gQEB0b1N0cmluZ1RhZyBtdXN0IGJlIGEgZGF0YSBwcm9wZXJ0eSwgbm90IGFuIGFjY2Vzc29yOiAke3EodGFnRGVzYyl9YCkmJihcbnR5cGVvZiB0YWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxuQ1goXG5jaGVjaylcbiBgT3duIEBAdG9TdHJpbmdUYWcgdmFsdWUgbXVzdCBiZSBhIHN0cmluZzogJHtxKHRhZ0Rlc2MudmFsdWUpfWApJiYoXG4hdGFnRGVzYy5lbnVtZXJhYmxlfHxcbkNYKGNoZWNrKSBgT3duIEBAdG9TdHJpbmdUYWcgbXVzdCBub3QgYmUgZW51bWVyYWJsZTogJHtxKHRhZ0Rlc2MpfWApKTtcblxuIH1cbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBDWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YDtcbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVPd25LZXkpO1xuIH07XG5cbi8qKlxuICogVW5kZXIgSGFyZGVuZWQgSlMgYSBwcm9taXNlIGlzIFwic2FmZVwiIGlmIGl0cyBgdGhlbmAgbWV0aG9kIGNhbiBiZSBjYWxsZWRcbiAqIHN5bmNocm9ub3VzbHkgd2l0aG91dCBnaXZpbmcgdGhlIHByb21pc2UgYW4gb3Bwb3J0dW5pdHkgZm9yIGFcbiAqIHJlZW50cmFuY3kgYXR0YWNrIGR1cmluZyB0aGF0IGNhbGwuXG4gKlxuICogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85XG4gKiByYWlzZXMgdGhlIGlzc3VlIG9mIHRlc3RpbmcgdGhhdCBhIHNwZWNpbWVuIGlzIGEgc2FmZSBwcm9taXNlXG4gKiBzdWNoIHRoYXQgdGhlIHRlc3QgYWxzbyBkb2VzIG5vdCBnaXZlIHRoZSBzcGVjaW1lbiBhXG4gKiByZWVudHJhbmN5IG9wcG9ydHVuaXR5LiBUaGF0IGlzIHdlbGwgYmV5b25kIHRoZSBhbWJpdGlvbiBoZXJlLlxuICogVE9ETyBUaG91Z2ggaWYgd2UgZmlndXJlIG91dCBhIG5pY2Ugc29sdXRpb24sIGl0IG1pZ2h0IGJlIGdvb2QgdG9cbiAqIHVzZSBpdCBoZXJlIGFzIHdlbGwuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tTYWZlUHJvbWlzZT0ocHIsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxDWChjaGVjaykgYCR7cHJ9IC0gTXVzdCBiZSBmcm96ZW5gKSYmKFxuaXNQcm9taXNlKHByKXx8Q1goY2hlY2spIGAke3ByfSAtIE11c3QgYmUgYSBwcm9taXNlYCkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbkNYKGNoZWNrKSBgJHtwcn0gLSBNdXN0IGluaGVyaXQgZnJvbSBQcm9taXNlLnByb3RvdHlwZTogJHtxKFxuZ2V0UHJvdG90eXBlT2YocHIpKVxuIH1gKSYmXG5jaGVja1Byb21pc2VPd25LZXlzKC8qKiBAdHlwZSB7UHJvbWlzZX0gKi9wcixjaGVjaykpO1xuXG4gfTtcbmhhcmRlbihjaGVja1NhZmVQcm9taXNlKTtcblxuLyoqXG4gKiBEZXRlcm1pbmUgaWYgdGhlIGFyZ3VtZW50IGlzIGEgUHJvbWlzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHByIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7cHIgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHByb21pc2VcbiAqL1xuY29uc3QgICAgICAgIGlzU2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwciwoeCk9PngpOyRozY9fb25jZS5pc1NhZmVQcm9taXNlKGlzU2FmZVByb21pc2UpO1xuaGFyZGVuKGlzU2FmZVByb21pc2UpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0U2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwcixhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNTYWZlUHJvbWlzZSI6WyJpc1NhZmVQcm9taXNlIl0sImFzc2VydFNhZmVQcm9taXNlIjpbImFzc2VydFNhZmVQcm9taXNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3RyaW5nLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vudi1vcHRpb25zIiwiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLEZhaWw7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoga25vdyBhYm91dGBpc1dlbGxGb3JtZWRgKi9cbmNvbnN0IGhhc1dlbGxGb3JtZWRTdHJpbmdNZXRob2Q9ISFTdHJpbmcucHJvdG90eXBlLmlzV2VsbEZvcm1lZDtcblxuLyoqXG4gKiBJcyB0aGUgYXJndW1lbnQgYSB3ZWxsLWZvcm1lZCBzdHJpbmc/XG4gKlxuICogVW5mb3J0dW5hdGVseSwgdGhlXG4gKiBbc3RhbmRhcmQgYnVpbHQtaW4gYFN0cmluZy5wcm90b3R5cGUuaXNXZWxsRm9ybWVkYF0oaHR0cHM6Ly9naXRodWIuY29tL3RjMzkvcHJvcG9zYWwtaXMtdXN2LXN0cmluZylcbiAqIGRvZXMgYSBUb1N0cmluZyBvbiBpdHMgaW5wdXQsIGNhdXNpbmcgaXQgdG8ganVkZ2Ugbm9uLXN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MgaWYgdGhleSBjb2VyY2UgdG8gYSB3ZWxsLWZvcm1lZCBzdHJpbmdzLiBUaGlzXG4gKiByZWNhcGl0dWxhdGVzIHRoZSBtaXN0YWtlIGluIGhhdmluZyB0aGUgZ2xvYmFsIGBpc05hTmAgY29lcmNlIGl0cyBpbnB1dHMsXG4gKiBjYXVzaW5nIGl0IHRvIGp1ZGdlIG5vbi1zdHJpbmcgdG8gYmUgTmFOIGlmIHRoZXkgY29lcmNlIHRvIE5hTi5cbiAqXG4gKiBUaGlzIGBpc1dlbGxGb3JtZWRTdHJpbmdgIGZ1bmN0aW9uIG9ubHkganVkZ2VzIHdlbGwtZm9ybWVkIHN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MuIEZvciBhbGwgbm9uLXN0cmluZ3MgaXQgcmV0dXJucyBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge3N0ciBpcyBzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBpc1dlbGxGb3JtZWRTdHJpbmc9aGFzV2VsbEZvcm1lZFN0cmluZ01ldGhvZD9cbihzdHIpPT50eXBlb2Ygc3RyPT09J3N0cmluZycmJnN0ci5pc1dlbGxGb3JtZWQoKTpcbihzdHIpPT57XG5pZih0eXBlb2Ygc3RyIT09J3N0cmluZycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmZvcihjb25zdCBjaCBvZiBzdHIpe1xuLyogVGhlIHN0cmluZyBpdGVyYXRvciBpdGVyYXRlcyBieSBVbmljb2RlIGNvZGUgcG9pbnQsIG5vdCovXG4vKiBVVEYxNiBjb2RlIHVuaXQuIEJ1dCBpZiBpdCBlbmNvdW50ZXJzIGFuIHVucGFpcmVkIHN1cnJvZ2F0ZSwqL1xuLyogaXQgd2lsbCBwcm9kdWNlIGl0LiovXG5jb25zdCBjcD0vKiogQHR5cGUge251bWJlcn0gKi9jaC5jb2RlUG9pbnRBdCgwKTtcbmlmKGNwPj0weGQ4MDAmJmNwPD0weGRmZmYpe1xuLyogQWxsIHN1cnJvZ2F0ZXMgYXJlIGluIHRoaXMgcmFuZ2UuIFRoZSBzdHJpbmcgaXRlcmF0b3Igb25seSovXG4vKiBwcm9kdWNlcyBhIGNoYXJhY3RlciBpbiB0aGlzIHJhbmdlIGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzLCovXG4vKiB3aGljaCBvbmx5IGhhcHBlbnMgaWYgdGhlIHN0cmluZyBpcyBub3Qgd2VsbC1mb3JtZWQuKi9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNXZWxsRm9ybWVkU3RyaW5nKGlzV2VsbEZvcm1lZFN0cmluZyk7XG5oYXJkZW4oaXNXZWxsRm9ybWVkU3RyaW5nKTtcblxuLyoqXG4gKiBSZXR1cm5zIG5vcm1hbGx5IHdoZW4gYGlzV2VsbEZvcm1lZFN0cmluZyhzdHIpYCB3b3VsZCByZXR1cm4gdHJ1ZS5cbiAqIFRocm93cyBhIGRpYWdub3N0aWMgZXJyb3Igd2hlbiBgaXNXZWxsRm9ybWVkU3RyaW5nKHN0cilgIHdvdWxkIHJldHVybiBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge2Fzc2VydHMgc3RyIGlzIHN0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFdlbGxGb3JtZWRTdHJpbmc9KHN0cik9PntcbmlzV2VsbEZvcm1lZFN0cmluZyhzdHIpfHxGYWlsIGBFeHBlY3RlZCB3ZWxsLWZvcm1lZCB1bmljb2RlIHN0cmluZzogJHtzdHJ9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRXZWxsRm9ybWVkU3RyaW5nKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuXG5jb25zdCBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEU9XG5nZXRFbnZpcm9ubWVudE9wdGlvbignT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFJywnZGlzYWJsZWQnLFtcbidlbmFibGVkJ10pPT09XG4nZW5hYmxlZCc7XG5cbi8qKlxuICogRm9yIG5vdyxcbiAqIGlmIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGVudmlyb25tZW50IG9wdGlvbiBpcyBgJ2VuYWJsZWQnYCxcbiAqIHRoZW4gYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBpcyB0aGUgc2FtZSBhcyBgYXNzZXJ0V2VsbEZvcm1lZFN0cmluZ2AuXG4gKiBPdGhlcndpc2UgYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBqdXN0IGFzc2VydHMgdGhhdCBgc3RyYCBpcyBhIHN0cmluZy5cbiAqXG4gKiBDdXJyZW50bHksIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGRlZmF1bHRzIHRvIGAnZGlzYWJsZWQnYFxuICogYmVjYXVzZSB3ZSBkbyBub3QgeWV0IGtub3cgdGhlIHBlcmZvcm1hbmNlIGltcGFjdC4gTGF0ZXIsIGlmIHdlIGRlY2lkZSB3ZVxuICogY2FuIGFmZm9yZCBpdCwgd2UnbGwgZmlyc3QgY2hhbmdlIHRoZSBkZWZhdWx0IHRvIGAnZW5hYmxlZCdgIGFuZCB1bHRpbWF0ZWx5XG4gKiByZW1vdmUgdGhlIHN3aXRjaCBhbHRvZ2V0aGVyLiBCZSBwcmVwYXJlZCBmb3IgdGhlc2UgY2hhbmdlcy5cbiAqXG4gKiBUT0RPIG9uY2UgdGhlIHN3aXRjaCBpcyByZW1vdmVkLCBzaW1wbGlmeSBgYXNzZXJ0UGFzc2FibGVTdHJpbmdgIHRvXG4gKiBzaW1wbHkgYmUgYGFzc2VydFdlbGxGb3JtZWRTdHJpbmdgLlxuICpcbiAqIEBwYXJhbSB7IHVua25vd24gfSBzdHJcbiAqIEByZXR1cm5zIHthc3NlcnRzIHN0ciBpcyBzdHJpbmcgfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTdHJpbmc9KHN0cik9PntcbnR5cGVvZiBzdHI9PT0nc3RyaW5nJ3x8RmFpbCBgRXhwZWN0ZWQgc3RyaW5nICR7c3RyfWA7XG4hT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFfHxhc3NlcnRXZWxsRm9ybWVkU3RyaW5nKHN0cik7XG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTdHJpbmcoYXNzZXJ0UGFzc2FibGVTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3RyaW5nKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzV2VsbEZvcm1lZFN0cmluZyI6WyJpc1dlbGxGb3JtZWRTdHJpbmciXSwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyI6WyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIl0sImFzc2VydFBhc3NhYmxlU3RyaW5nIjpbImFzc2VydFBhc3NhYmxlU3RyaW5nIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMs77KO4EgAAuBIAACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3ltYm9sLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjNj19vbmNlLmlzUGFzc2FibGVTeW1ib2woaXNQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oaXNQYXNzYWJsZVN5bWJvbCk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZVN5bWJvbD0oc3ltKT0+XG5pc1Bhc3NhYmxlU3ltYm9sKHN5bSl8fFxuRmFpbCBgT25seSByZWdpc3RlcmVkIHN5bWJvbHMgb3Igd2VsbC1rbm93biBzeW1ib2xzIGFyZSBwYXNzYWJsZTogJHtxKHN5bSl9YDskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTeW1ib2woYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3ltYm9sKTtcblxuLyoqXG4gKiBJZiBgc3ltYCBpcyBhIHBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGEgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzXG4gKiBzeW1ib2wuIElmIGBzeW1gIGlzIGEgbm9uLXBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGB1bmRlZmluZWRgLlxuICpcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuIFNpbmNlIHRoZSByZWdpc3RyYXRpb24gc3RyaW5nIG9mIGEgcmVnaXN0ZXJlZCBzeW1ib2wgY2FuIGJlIGFueVxuICogc3RyaW5nLCBpZiB3ZSBzaW1wbHkgdXNlZCB0aGF0IHRvIGlkZW50aWZ5IHRob3NlIHN5bWJvbHMsIHRoZXJlIHdvdWxkIG5vdFxuICogYmUgYW55IHJlbWFpbmluZyBzdHJpbmdzIGxlZnQgb3ZlciB0byBpZGVudGlmeSB0aGUgd2VsbC1rbm93biBzeW1ib2xzLlxuICogSW5zdGVhZCwgd2UgcmVzZXJ2ZSBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGBcIkBAXCJgIGZvciBwdXJwb3NlcyBvZiB0aGlzXG4gKiBlbmNvZGluZy4gV2UgaWRlbnRpZnkgYSB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiBieSBwcmVmaXhpbmcgdGhlIHByb3BlcnR5IG5hbWUgd2l0aCBgXCJAQFwiYCwgc3VjaCBhcyBgXCJAQGl0ZXJhdG9yXCJgLlxuICogRm9yIHJlZ2lzdGVyZWQgc3ltYm9scyB3aG9zZSBuYW1lIGhhcHBlbnMgdG8gYmVnaW4gd2l0aCBgXCJAQFwiYCwgc3VjaFxuICogYXMgYFN5bWJvbC5mb3IoJ0BAaXRlcmF0b3InKWAgb3IgYFN5bWJvbC5mb3IoJ0BAZm9vJylgLCB3ZSBpZGVudGlmeVxuICogdGhlbSBieSBwcmVmaXhpbmcgdGhlbSB3aXRoIGFuIGV4dHJhIGBcIkBAXCJgLCBzdWNoIGFzXG4gKiBgXCJAQEBAaXRlcmF0b3JcImAgb3IgYFwiQEBAQGZvb1wiYC4gKFRoaXMgaXMgdGhlIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmdcbiAqIHRlY2huaXF1ZS4pXG4gKlxuICogQHBhcmFtIHtzeW1ib2x9IHN5bVxuICogQHJldHVybnMge3N0cmluZz19XG4gKi9cbmNvbnN0ICAgICAgICBuYW1lRm9yUGFzc2FibGVTeW1ib2w9KHN5bSk9PntcbmNvbnN0IG5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYobmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gd2VsbEtub3duU3ltYm9sTmFtZXMuZ2V0KHN5bSk7XG4gfVxuaWYobmFtZS5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBgQEAke25hbWV9YDtcbiB9XG5yZXR1cm4gbmFtZTtcbiB9OyRozY9fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaM2PX29uY2UucGFzc2FibGVTeW1ib2xGb3JOYW1lKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG5oYXJkZW4ocGFzc2FibGVTeW1ib2xGb3JOYW1lKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUGFzc2FibGVTeW1ib2wiOlsiaXNQYXNzYWJsZVN5bWJvbCJdLCJhc3NlcnRQYXNzYWJsZVN5bWJvbCI6WyJhc3NlcnRQYXNzYWJsZVN5bWJvbCJdLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiOlsibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sInBhc3NhYmxlU3ltYm9sRm9yTmFtZSI6WyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADBplv5UIAACVCAAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90YWdnZWQuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlRhZ2dlZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxnZXRPd25EYXRhRGVzY3JpcHRvcixjaGVja1Bhc3NTdHlsZTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrVGFnUmVjb3JkID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXSxbXCJjaGVja1Bhc3NTdHlsZVwiLCBbJGjNj19hID0+IChjaGVja1Bhc3NTdHlsZSA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtJTVBPUlQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBUYWdnZWRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTondGFnZ2VkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuY2hlY2tQYXNzU3R5bGUoY2FuZGlkYXRlLGNhbmRpZGF0ZVtQQVNTX1NUWUxFXSwndGFnZ2VkJyxjaGVjayksXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNoZWNrVGFnUmVjb3JkKGNhbmRpZGF0ZSwndGFnZ2VkJyxhc3NlcnRDaGVja2VyKTtcblxuLyogVHlwZWNhc3RzIG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbmNvbnN0IHBhc3NTdHlsZUtleT0vKiogQHR5cGUge3Vua25vd259ICovUEFTU19TVFlMRTtcbmNvbnN0IHRhZ0tleT0vKiogQHR5cGUge3Vua25vd259ICovU3ltYm9sLnRvU3RyaW5nVGFnO1xuY29uc3R7XG4vKiBjaGVja1RhZ1JlY29yZCBhbHJlYWR5IHZlcmlmaWVkIFBBU1NfU1RZTEUgYW5kIFN5bWJvbC50b1N0cmluZ1RhZyBvd24gZGF0YSBwcm9wZXJ0aWVzLiovXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovcGFzc1N0eWxlS2V5XTpfcGFzc1N0eWxlRGVzYyxcblsvKiogQHR5cGUge3N0cmluZ30gKi90YWdLZXldOl9sYWJlbERlc2MsXG5wYXlsb2FkOl9wYXlsb2FkRGVzYywvKiB2YWx1ZSBjaGVja2VkIGJ5IHJlY3Vyc2l2ZSB3YWxrIGF0IHRoZSBlbmQqL1xuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg9PT0wfHxcbkZhaWwgYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiB0YWdnZWQgcmVjb3JkICR7b3duS2V5cyhyZXN0RGVzY3MpfWA7XG5cbi8qIFZhbGlkYXRlIHRoYXQgdGhlICdwYXlsb2FkJyBwcm9wZXJ0eSBpcyBvd24vZGF0YS9lbnVtZXJhYmxlKi9cbi8qIGFuZCBpdHMgYXNzb2NpYXRlZCB2YWx1ZSBpcyByZWN1cnNpdmVseSBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKS52YWx1ZSk7XG5cbiB9fSk7JGjNj19vbmNlLlRhZ2dlZEhlbHBlcihUYWdnZWRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKomXX/AsAAPwLAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEscGFzc1N0eWxlT2Y7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjNj19hID0+IChwYXNzU3R5bGVPZiA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoqIEBpbXBvcnQge0NvcHlBcnJheSwgQ29weVJlY29yZCwgUGFzc2FibGUsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHBhc3MtYnktY29weSBhcnJheSwgQUtBIGEgXCJjb3B5QXJyYXlcIlxuICogaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjNj19vbmNlLmlzQ29weUFycmF5KGlzQ29weUFycmF5KTtcbmhhcmRlbihpc0NvcHlBcnJheSk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBBS0EgYVxuICogXCJjb3B5UmVjb3JkXCIgaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaM2PX29uY2UuaXNSZWNvcmQoaXNSZWNvcmQpO1xuaGFyZGVuKGlzUmVjb3JkKTtcblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHJlbW90YWJsZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtyZW1vdGFibGUgaXMgUmVtb3RhYmxlT2JqZWN0fVxuICovXG5jb25zdCBpc1JlbW90YWJsZT0ocmVtb3RhYmxlKT0+cGFzc1N0eWxlT2YocmVtb3RhYmxlKT09PSdyZW1vdGFibGUnOyRozY9fb25jZS5pc1JlbW90YWJsZShpc1JlbW90YWJsZSk7XG5oYXJkZW4oaXNSZW1vdGFibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaM2PX29uY2UuYXNzZXJ0Q29weUFycmF5KGFzc2VydENvcHlBcnJheSk7XG5oYXJkZW4oYXNzZXJ0Q29weUFycmF5KTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuY29uc3QgYXNzZXJ0UmVjb3JkPShyZWNvcmQsb3B0TmFtZU9mUmVjb3JkPSdBbGxlZ2VkIHJlY29yZCcpPT57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVjb3JkKTtcbnBhc3NTdHlsZT09PSdjb3B5UmVjb3JkJ3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mUmVjb3JkKX0gJHtyZWNvcmR9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBub3QgJHtxKFxucGFzc1N0eWxlKVxuIH1gO1xuIH07JGjNj19vbmNlLmFzc2VydFJlY29yZChhc3NlcnRSZWNvcmQpO1xuaGFyZGVuKGFzc2VydFJlY29yZCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlbW90YWJsZVxuICogQHJldHVybnMge2Fzc2VydHMgcmVtb3RhYmxlIGlzIFJlbW90YWJsZU9iamVjdH1cbiAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRSZW1vdGFibGUoYXNzZXJ0UmVtb3RhYmxlKTtcbmhhcmRlbihhc3NlcnRSZW1vdGFibGUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5QXJyYXkiOlsiaXNDb3B5QXJyYXkiXSwiaXNSZWNvcmQiOlsiaXNSZWNvcmQiXSwiaXNSZW1vdGFibGUiOlsiaXNSZW1vdGFibGUiXSwiYXNzZXJ0Q29weUFycmF5IjpbImFzc2VydENvcHlBcnJheSJdLCJhc3NlcnRSZWNvcmQiOlsiYXNzZXJ0UmVjb3JkIl0sImFzc2VydFJlbW90YWJsZSI6WyJhc3NlcnRSZW1vdGFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA7PqD1JMJAACTCQAAIQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsIi4vc3JjL21lbW8tcmFjZS5qcyIsIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VQcm9taXNlS2l0IiwicmFjZVByb21pc2VzIl0sInJlZXhwb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0LG1lbW9SYWNlOyRozY9faW1wb3J0cyhbW1wiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNcIiwgW1tcIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdFwiLCBbJGjNj19hID0+IChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQgPSAkaM2PX2EpXV1dXSxbXCIuL3NyYy9tZW1vLXJhY2UuanNcIiwgW1tcIm1lbW9SYWNlXCIsIFskaM2PX2EgPT4gKG1lbW9SYWNlID0gJGjNj19hKV1dXV0sW1wiLi9zcmMvaXMtcHJvbWlzZS5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VQcm9taXNlS2l0LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlUHJvbWlzZUtpdFwifSk7JGjNj19vbmNlLm1ha2VQcm9taXNlS2l0KG1ha2VQcm9taXNlS2l0KTtPYmplY3QuZGVmaW5lUHJvcGVydHkocmFjZVByb21pc2VzLCAnbmFtZScsIHt2YWx1ZTogXCJyYWNlUHJvbWlzZXNcIn0pOyRozY9fb25jZS5yYWNlUHJvbWlzZXMocmFjZVByb21pc2VzKTsgICBcblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gKi9cbmNvbnN0IEJlc3RQaXBlbGluYWJsZVByb21pc2U9Z2xvYmFsVGhpcy5IYW5kbGVkUHJvbWlzZXx8UHJvbWlzZTtcblxuLyoqXG4gKiBtYWtlUHJvbWlzZUtpdCgpIGJ1aWxkcyBhIFByb21pc2Ugb2JqZWN0LCBhbmQgcmV0dXJucyBhIHJlY29yZFxuICogY29udGFpbmluZyB0aGUgcHJvbWlzZSBpdHNlbGYsIGFzIHdlbGwgYXMgc2VwYXJhdGUgZmFjZXRzIGZvciByZXNvbHZpbmdcbiAqIGFuZCByZWplY3RpbmcgaXQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtJTVBPUlQoJy4vc3JjL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPn1cbiAqL1xuZnVuY3Rpb24gICAgICAgIG1ha2VQcm9taXNlS2l0KCl7XG5jb25zdHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn09bWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCk7XG5cbmNvbnN0IHByb21pc2U9bmV3IEJlc3RQaXBlbGluYWJsZVByb21pc2UoZXhlY3V0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtwcm9taXNlLHJlc29sdmUscmVqZWN0fSk7XG4gfVxuaGFyZGVuKG1ha2VQcm9taXNlS2l0KTtcblxuLyogTkI6IEFub3RoZXIgaW1wbGVtZW50YXRpb24gZm9yIFByb21pc2UucmFjZSB3b3VsZCBiZSB0byB1c2UgdGhlIHJlbGVhc2luZyBleGVjdXRvciwqL1xuLyogSG93ZXZlciB3aGlsZSBpdCB3b3VsZCBubyBsb25nZXIgbGVhayB0aGUgcmFjZWQgcHJvbWlzZSBvYmplY3RzIHRoZW1zZWx2ZXMsIGl0IHdvdWxkKi9cbi8qIHN0aWxsIGxlYWsgcmVhY3Rpb25zIG9uIHRoZSBub24tcmVzb2x2ZWQgcHJvbWlzZXMgY29udGVuZGluZyBmb3IgdGhlIHJhY2UuKi9cblxuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5mdW5jdGlvbiAgICAgICAgcmFjZVByb21pc2VzKHZhbHVlcyl7XG5yZXR1cm4gaGFyZGVuKG1lbW9SYWNlLmNhbGwoQmVzdFBpcGVsaW5hYmxlUHJvbWlzZSx2YWx1ZXMpKTtcbiB9XG5oYXJkZW4ocmFjZVByb21pc2VzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlS2l0IjpbIm1ha2VQcm9taXNlS2l0Il0sInJhY2VQcm9taXNlcyI6WyJyYWNlUHJvbWlzZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvaXMtcHJvbWlzZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiaXNQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNQcm9taXNlLCAnbmFtZScsIHt2YWx1ZTogXCJpc1Byb21pc2VcIn0pOyRozY9fb25jZS5pc1Byb21pc2UoaXNQcm9taXNlKTsgICAvKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gbWF5YmVQcm9taXNlIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7bWF5YmVQcm9taXNlIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmZ1bmN0aW9uICAgICAgICBpc1Byb21pc2UobWF5YmVQcm9taXNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUobWF5YmVQcm9taXNlKT09PW1heWJlUHJvbWlzZTtcbiB9XG5oYXJkZW4oaXNQcm9taXNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJvbWlzZSI6WyJpc1Byb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAASLuyqBcTAAAXEwAAKQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtZW1vUmFjZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgLyogSW5pdGlhbCB2ZXJzaW9uIGF1dGhvcmVkIGJ5IEJyaWFuIEtpbTpcbmh0dHBzOi8vZ2l0aHViLmNvbS9ub2RlanMvbm9kZS9pc3N1ZXMvMTc0NjkjaXNzdWVjb21tZW50LTY4NTIxNjc3N1xuIFRoaXMgaXMgZnJlZSBhbmQgdW5lbmN1bWJlcmVkIHNvZnR3YXJlIHJlbGVhc2VkIGludG8gdGhlIHB1YmxpYyBkb21haW4uXG4gQW55b25lIGlzIGZyZWUgdG8gY29weSwgbW9kaWZ5LCBwdWJsaXNoLCB1c2UsIGNvbXBpbGUsIHNlbGwsIG9yXG5kaXN0cmlidXRlIHRoaXMgc29mdHdhcmUsIGVpdGhlciBpbiBzb3VyY2UgY29kZSBmb3JtIG9yIGFzIGEgY29tcGlsZWRcbmJpbmFyeSwgZm9yIGFueSBwdXJwb3NlLCBjb21tZXJjaWFsIG9yIG5vbi1jb21tZXJjaWFsLCBhbmQgYnkgYW55XG5tZWFucy5cbiBJbiBqdXJpc2RpY3Rpb25zIHRoYXQgcmVjb2duaXplIGNvcHlyaWdodCBsYXdzLCB0aGUgYXV0aG9yIG9yIGF1dGhvcnNcbm9mIHRoaXMgc29mdHdhcmUgZGVkaWNhdGUgYW55IGFuZCBhbGwgY29weXJpZ2h0IGludGVyZXN0IGluIHRoZVxuc29mdHdhcmUgdG8gdGhlIHB1YmxpYyBkb21haW4uIFdlIG1ha2UgdGhpcyBkZWRpY2F0aW9uIGZvciB0aGUgYmVuZWZpdFxub2YgdGhlIHB1YmxpYyBhdCBsYXJnZSBhbmQgdG8gdGhlIGRldHJpbWVudCBvZiBvdXIgaGVpcnMgYW5kXG5zdWNjZXNzb3JzLiBXZSBpbnRlbmQgdGhpcyBkZWRpY2F0aW9uIHRvIGJlIGFuIG92ZXJ0IGFjdCBvZlxucmVsaW5xdWlzaG1lbnQgaW4gcGVycGV0dWl0eSBvZiBhbGwgcHJlc2VudCBhbmQgZnV0dXJlIHJpZ2h0cyB0byB0aGlzXG5zb2Z0d2FyZSB1bmRlciBjb3B5cmlnaHQgbGF3LlxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsXG5FWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Zcbk1FUkNIQU5UQUJJTElUWSwgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC5cbklOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SXG5PVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSxcbkFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUlxuT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLlxuIEZvciBtb3JlIGluZm9ybWF0aW9uLCBwbGVhc2UgcmVmZXIgdG8gPGh0dHA6Ly91bmxpY2Vuc2Uub3JnLz5cbiovXG5cblxuXG5cblxuXG5cbmNvbnN0IGlzT2JqZWN0PSh2YWx1ZSk9Pk9iamVjdCh2YWx1ZSk9PT12YWx1ZTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgW1Q9YW55XVxuICogQHR5cGVkZWYge29iamVjdH0gRGVmZXJyZWRcbiAqIEBwcm9wZXJ0eSB7KHZhbHVlPzogSU1QT1JUKFwiLi90eXBlcy5qc1wiKS5FUmVmPFQ+ICkgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHByb3BlcnR5IHsoZXJyPzogYW55ICkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IG5ldmVyXG4gKiAgfCB7c2V0dGxlZDogZmFsc2UsIGRlZmVycmVkczogU2V0PERlZmVycmVkPn1cbiAqICB8IHtzZXR0bGVkOiB0cnVlLCBkZWZlcnJlZHM/OiB1bmRlZmluZWR9XG4gKiB9IFByb21pc2VNZW1vUmVjb3JkXG4gKi9cblxuLyogS2V5cyBhcmUgdGhlIHZhbHVlcyBwYXNzZWQgdG8gcmFjZSwgdmFsdWVzIGFyZSBhIHJlY29yZCBvZiBkYXRhIGNvbnRhaW5pbmcgYSovXG4vKiBzZXQgb2YgZGVmZXJyZWRzIGFuZCB3aGV0aGVyIHRoZSB2YWx1ZSBoYXMgc2V0dGxlZC4qL1xuLyoqIEB0eXBlIHtXZWFrTWFwPG9iamVjdCwgUHJvbWlzZU1lbW9SZWNvcmQ+fSAqL1xuY29uc3Qga25vd25Qcm9taXNlcz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZU1lbW9SZWNvcmQgfCB1bmRlZmluZWR9IHJlY29yZFxuICogQHJldHVybnMge1NldDxEZWZlcnJlZD59XG4gKi9cbmNvbnN0IG1hcmtTZXR0bGVkPShyZWNvcmQpPT57XG5pZighcmVjb3JkfHxyZWNvcmQuc2V0dGxlZCl7XG5yZXR1cm4gbmV3IFNldCgpO1xuIH1cblxuY29uc3R7ZGVmZXJyZWRzfT1yZWNvcmQ7XG5PYmplY3QuYXNzaWduKHJlY29yZCx7XG5kZWZlcnJlZHM6dW5kZWZpbmVkLFxuc2V0dGxlZDp0cnVlfSk7XG5cbk9iamVjdC5mcmVlemUocmVjb3JkKTtcbnJldHVybiBkZWZlcnJlZHM7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcmV0dXJucyB7UHJvbWlzZU1lbW9SZWNvcmR9XG4gKi9cbmNvbnN0IGdldE1lbW9SZWNvcmQ9KHZhbHVlKT0+e1xuaWYoIWlzT2JqZWN0KHZhbHVlKSl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIGEgcHJpbWl0aXZlLCBhdHRlbXB0aW5nIHRvIHVzZSBpdCBhcyBhIGtleSBpbiB0aGUqL1xuLyogd2Vha21hcCB3b3VsZCB0aHJvdyBhbiBlcnJvci4gTHVja2lseSwgaXQgaXMgc2FmZSB0byBjYWxsKi9cbi8qIGBQcm9taXNlLnJlc29sdmUoY29udGVuZGVyKS50aGVuYCBvbiBhIHByaW1pdGl2ZSB2YWx1ZSBtdWx0aXBsZSB0aW1lcyovXG4vKiBiZWNhdXNlIHRoZSBwcm9taXNlIGZ1bGZpbGxzIGltbWVkaWF0ZWx5LiBTbyB3ZSBmYWtlIGEgc2V0dGxlZCByZWNvcmQuKi9cbnJldHVybiBoYXJkZW4oe3NldHRsZWQ6dHJ1ZX0pO1xuIH1cblxubGV0IHJlY29yZD1rbm93blByb21pc2VzLmdldCh2YWx1ZSk7XG5cbmlmKCFyZWNvcmQpe1xucmVjb3JkPXtkZWZlcnJlZHM6bmV3IFNldCgpLHNldHRsZWQ6ZmFsc2V9O1xua25vd25Qcm9taXNlcy5zZXQodmFsdWUscmVjb3JkKTtcbi8qIFRoaXMgY2FsbCB0byBgdGhlbmAgaGFwcGVucyBvbmNlIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIHZhbHVlLiovXG5Qcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW4oXG4odmFsKT0+e1xuZm9yKGNvbnN0e3Jlc29sdmV9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZXNvbHZlKHZhbCk7XG4gfVxuIH0sXG4oZXJyKT0+e1xuZm9yKGNvbnN0e3JlamVjdH1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlamVjdChlcnIpO1xuIH1cbiB9KTtcblxuIH1cbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3R7cmFjZX09e1xuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHRlbXBsYXRlIHtQcm9taXNlQ29uc3RydWN0b3J9IFtQPVByb21pc2VDb25zdHJ1Y3Rvcl1cbiAqIEB0aGlzIHtQfVxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5yYWNlKHZhbHVlcyl7XG5sZXQgZGVmZXJyZWQ7XG4vKiogQHR5cGUge1suLi5UXX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgZmlsbGVkIGJ5IHRoZSBsb29wKi9cbmNvbnN0IGNhY2hlZFZhbHVlcz1bXTtcbmNvbnN0IEM9dGhpcztcbmNvbnN0IHJlc3VsdD1uZXcgQygocmVzb2x2ZSxyZWplY3QpPT57XG5kZWZlcnJlZD17cmVzb2x2ZSxyZWplY3R9O1xuZm9yKGNvbnN0IHZhbHVlIG9mIHZhbHVlcyl7XG5jYWNoZWRWYWx1ZXMucHVzaCh2YWx1ZSk7XG5jb25zdHtzZXR0bGVkLGRlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihzZXR0bGVkKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgc2V0dGxlZCAoaW5jbHVkaW5nIHByaW1pdGl2ZXMpLCBpdCBpcyBzYWZlKi9cbi8qIHRvIGNhbGwgYFByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbmAgb24gaXQuKi9cbkMucmVzb2x2ZSh2YWx1ZSkudGhlbihyZXNvbHZlLHJlamVjdCk7XG4gfWVsc2V7XG5kZWZlcnJlZHMuYWRkKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuXG4vKiBUaGUgZmluYWxseSBjYWxsYmFjayBleGVjdXRlcyB3aGVuIGFueSB2YWx1ZSBzZXR0bGVzLCBwcmV2ZW50aW5nIGFueSBvZiovXG4vKiB0aGUgdW5yZXNvbHZlZCB2YWx1ZXMgZnJvbSByZXRhaW5pbmcgYSByZWZlcmVuY2UgdG8gdGhlIHJlc29sdmVkIHZhbHVlLiovXG5yZXR1cm4gcmVzdWx0LmZpbmFsbHkoKCk9PntcbmZvcihjb25zdCB2YWx1ZSBvZiBjYWNoZWRWYWx1ZXMpe1xuY29uc3R7ZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKGRlZmVycmVkcyl7XG5kZWZlcnJlZHMuZGVsZXRlKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuIH19OyRozY9fb25jZS5yYWNlKHJhY2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWVtb1JhY2UiOlsicmFjZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACnhwxnegcAAHoHAAA0AAAAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAY2FsbGJhY2sgUHJvbWlzZUV4ZWN1dG9yIFRoZSBwcm9taXNlIGV4ZWN1dG9yXG4gKiBAcGFyYW0geyh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCkgYnVpbGRzIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyB3aGljaCBkcm9wIHJlZmVyZW5jZXNcbiAqIHRvIHRoZSByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgZ2F0aGVyZWQgZnJvbSBhbiBleGVjdXRvciB0byBiZSB1c2VkIHdpdGggYVxuICogcHJvbWlzZSBjb25zdHJ1Y3Rvci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1BpY2s8SU1QT1JUKCcuL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPiwgJ3Jlc29sdmUnIHwgJ3JlamVjdCc+ICYgeyBleGVjdXRvcjogUHJvbWlzZUV4ZWN1dG9yPFQ+fX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdD0oKT0+e1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKCh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZXNvbHZlO1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKChyZWFzb246IHVua25vd24pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVqZWN0O1xuXG4vKiogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+fSB2YWx1ZSAqL1xuY29uc3QgcmVzb2x2ZT0odmFsdWUpPT57XG5pZihpbnRlcm5hbFJlc29sdmUpe1xuaW50ZXJuYWxSZXNvbHZlKHZhbHVlKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT1udWxsKTtcbiB9XG4gfTtcblxuLyoqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uICovXG5jb25zdCByZWplY3Q9KHJlYXNvbik9PntcbmlmKGludGVybmFsUmVqZWN0KXtcbmludGVybmFsUmVqZWN0KHJlYXNvbik7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZWplY3Q9PT1udWxsKTtcbiB9XG4gfTtcblxuY29uc3QgZXhlY3V0b3I9KHJlcyxyZWopPT57XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09dW5kZWZpbmVkJiZpbnRlcm5hbFJlamVjdD09PXVuZGVmaW5lZCk7XG5pbnRlcm5hbFJlc29sdmU9cmVzO1xuaW50ZXJuYWxSZWplY3Q9cmVqO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfSk7XG4gfTskaM2PX29uY2UubWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG5oYXJkZW4obWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMLX9K+kBgAApAYAACYAAABAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy92YXRzL29sbGFtYS5qc3siaW1wb3J0cyI6WyJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiYnVpbGRSb290T2JqZWN0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IEZhcjskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcIkZhclwiLCBbJGjNj19hID0+IChGYXIgPSAkaM2PX2EpXV1dXV0pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShidWlsZFJvb3RPYmplY3QsICduYW1lJywge3ZhbHVlOiBcImJ1aWxkUm9vdE9iamVjdFwifSk7JGjNj19vbmNlLmJ1aWxkUm9vdE9iamVjdChidWlsZFJvb3RPYmplY3QpOyAgIFxuXG4vKiBUaGUgZGVmYXVsdCBMTE0gbW9kZWwgdG8gdXNlLiovXG5jb25zdCBERUZBVUxUX01PREVMPSdkZWVwc2Vlay1yMToxLjViJztcblxuLyoqXG4gKiBCdWlsZCBmdW5jdGlvbiBmb3IgdGhlIExMTSB0ZXN0IHZhdC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHZhdFBvd2VycyAtIFNwZWNpYWwgcG93ZXJzIGdyYW50ZWQgdG8gdGhpcyB2YXQuXG4gKiBAcGFyYW0geygpID0+IFByb21pc2U8dW5rbm93bj59IHZhdFBvd2Vycy5jaGF0IC0gQSBtZXRob2QgZm9yIGF3YWl0aW5nIGNoYXQgcmVzdWx0cyBmcm9tIGFuIExMTS5cbiAqIEBwYXJhbSB7dW5rbm93bn0gcGFyYW1ldGVycyAtIEluaXRpYWxpemF0aW9uIHBhcmFtZXRlcnMgZnJvbSB0aGUgdmF0J3MgY29uZmlnIG9iamVjdC5cbiAqIEBwYXJhbSB7dW5rbm93bn0gX2JhZ2dhZ2UgLSBSb290IG9mIHZhdCdzIHBlcnNpc3RlbnQgc3RhdGUgKG5vdCB1c2VkIGhlcmUpLlxuICogQHJldHVybnMge3Vua25vd259IFRoZSByb290IG9iamVjdCBmb3IgdGhlIG5ldyB2YXQuXG4gKi9cbmZ1bmN0aW9uICAgICAgICBidWlsZFJvb3RPYmplY3QodmF0UG93ZXJzLHBhcmFtZXRlcnMsX2JhZ2dhZ2Upe1xuY29uc3QgbW9kZWw9cGFyYW1ldGVycz8ubW9kZWw/P0RFRkFVTFRfTU9ERUw7XG5jb25zdCBwcm9tcHQ9cGFyYW1ldGVycz8ucHJvbXB0Pz8gYFNheSBoZWxsby5gO1xuXG5jb25zb2xlLmxvZyggYFtMTE1dIGJ1aWxkUm9vdE9iamVjdCBcIiR7SlNPTi5zdHJpbmdpZnkoe21vZGVsLHByb21wdCx2YXRQb3dlcnN9KX1cImApO1xuXG5jb25zdHtjaGF0fT12YXRQb3dlcnM7XG5cbnJldHVybiBGYXIoJ3Jvb3QnLHtcbmJvb3RzdHJhcChfKXtcbmNoYXQoe1xubW9kZWwsXG5tZXNzYWdlczpbe3JvbGU6J3VzZXInLGNvbnRlbnQ6cHJvbXB0fV19KS5cbnRoZW4oKHJlc3BvbnNlKT0+e1xuY29uc29sZS5sb2coJ3Jlc3BvbnNlOicscmVzcG9uc2UpO1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9KS5jYXRjaCgocHJvYmxlbSk9PntcbmNvbnNvbGUuZXJyb3IoJ3Byb2JsZW06Jyxwcm9ibGVtKTtcbiB9KTtcbiB9LFxuaGVsbG8oZnJvbSl7XG5jb25zb2xlLmxvZyggYGhlbGxvLCAke2Zyb219YCk7XG4gfX0pO1xuXG4gfVxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYnVpbGRSb290T2JqZWN0IjpbImJ1aWxkUm9vdE9iamVjdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsBAh4DCgAAAAAAAAAAAD2dCov2OgAA9joAABQAAAAAAAAAAAAAAKSBAAAAAGNvbXBhcnRtZW50LW1hcC5qc29uUEsBAh4DCgAAAAAAAAAAAMJww2o9CgAAPQoAACEAAAAAAAAAAAAAAKSBKDsAAEBlbmRvL2NvbW1vbi12MS4yLjgvb2JqZWN0LW1hcC5qc1BLAQIeAwoAAAAAAAAAAADFGOc6lAEAAJQBAAAhAAAAAAAAAAAAAACkgaRFAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAXZuU6h4TAAAeEwAAKwAAAAAAAAAAAAAApIF3RwAAQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44L3NyYy9lbnYtb3B0aW9ucy5qc1BLAQIeAwoAAAAAAAAAAADnjB5W6QwAAOkMAAAcAAAAAAAAAAAAAACkgd5aAABAZW5kby9lcnJvcnMtdjEuMi44L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAH6dp+BROgAAUToAACMAAAAAAAAAAAAAAKSBAWgAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy9FLmpzUEsBAh4DCgAAAAAAAAAAAAS6w5NKAQAASgEAACkAAAAAAAAAAAAAAKSBk6IAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy9leHBvcnRzLmpzUEsBAh4DCgAAAAAAAAAAAG2wnmyYEQAAmBEAACcAAAAAAAAAAAAAAKSBJKQAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy9sb2NhbC5qc1BLAQIeAwoAAAAAAAAAAABt8TAWoRYAAKEWAAA1AAAAAAAAAAAAAACkgQG2AABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qc1BLAQIeAwoAAAAAAAAAAAAXhFMMeQMAAHkDAAApAAAAAAAAAAAAAACkgfXMAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbm8tc2hpbS5qc1BLAQIeAwoAAAAAAAAAAAAeuOfL7RAAAO0QAAAtAAAAAAAAAAAAAACkgbXQAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvdHJhY2stdHVybnMuanNQSwECHgMKAAAAAAAAAAAAP/DnOlYCAABWAgAAIwAAAAAAAAAAAAAApIHt4QAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvdXRpbHMuanNQSwECHgMKAAAAAAAAAAAAuIFp8HQHAAB0BwAAHQAAAAAAAAAAAAAApIGE5AAAQGVuZG8vbWFyc2hhbC12MS42LjIvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAbdiwbstvAADLbwAAKgAAAAAAAAAAAAAApIEz7AAAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL2VuY29kZVBhc3NhYmxlLmpzUEsBAh4DCgAAAAAAAAAAADGKruRKOgAASjoAACsAAAAAAAAAAAAAAKSBRlwBAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb0NhcERhdGEuanNQSwECHgMKAAAAAAAAAAAAFPXhEKs7AACrOwAALQAAAAAAAAAAAAAApIHZlgEAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL2VuY29kZVRvU21hbGxjYXBzLmpzUEsBAh4DCgAAAAAAAAAAAHBOnzJhLAAAYSwAACoAAAAAAAAAAAAAAKSBz9IBAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc1BLAQIeAwoAAAAAAAAAAACxBHnIGgcAABoHAAAtAAAAAAAAAAAAAACkgXj/AQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNQSwECHgMKAAAAAAAAAAAAE7Fc3pk3AACZNwAAIwAAAAAAAAAAAAAApIHdBgIAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL21hcnNoYWwuanNQSwECHgMKAAAAAAAAAAAAZrtByttBAADbQQAAJQAAAAAAAAAAAAAApIG3PgIAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL3JhbmtPcmRlci5qc1BLAQIeAwoAAAAAAAAAAAAEusOTSgEAAEoBAAAhAAAAAAAAAAAAAACkgdWAAgBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAai91qtYLAADWCwAAHgAAAAAAAAAAAAAApIFeggIAQGVuZG8vbmF0LXY1LjAuMTMvc3JjL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAKEpqrw/CgAAPwoAACAAAAAAAAAAAAAAAKSBcI4CAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAHmAfwwDCAAAAwgAACgAAAAAAAAAAAAAAKSB7ZgCAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5QXJyYXkuanNQSwECHgMKAAAAAAAAAAAArHWRoUkKAABJCgAAKQAAAAAAAAAAAAAApIE2oQIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2NvcHlSZWNvcmQuanNQSwECHgMKAAAAAAAAAAAAQdPIJCQVAAAkFQAALgAAAAAAAAAAAAAApIHGqwIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2RlZXBseUZ1bGZpbGxlZC5qc1BLAQIeAwoAAAAAAAAAAABREv3gLhsAAC4bAAAkAAAAAAAAAAAAAACkgTbBAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZXJyb3IuanNQSwECHgMKAAAAAAAAAAAAu5h1k2cIAABnCAAAKwAAAAAAAAAAAAAApIGm3AIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2l0ZXItaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAADeY8aaXCQAAFwkAAAnAAAAAAAAAAAAAACkgVblAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZS1mYXIuanNQSwECHgMKAAAAAAAAAAAAGVoiOh4FAAAeBQAAKQAAAAAAAAAAAAAApIH3CQMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL21ha2VUYWdnZWQuanNQSwECHgMKAAAAAAAAAAAAk3b0aRscAAAbHAAAMAAAAAAAAAAAAAAApIFcDwMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAKBGr854NgAAeDYAACoAAAAAAAAAAAAAAKSBxSsDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9wYXNzU3R5bGVPZi5qc1BLAQIeAwoAAAAAAAAAAACC5ALHEiIAABIiAAAoAAAAAAAAAAAAAACkgYViAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcmVtb3RhYmxlLmpzUEsBAh4DCgAAAAAAAAAAAARGFca6FAAAuhQAACsAAAAAAAAAAAAAAKSB3YQDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9zYWZlLXByb21pc2UuanNQSwECHgMKAAAAAAAAAAAAQAqyjhQPAAAUDwAAJQAAAAAAAAAAAAAApIHgmQMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3N0cmluZy5qc1BLAQIeAwoAAAAAAAAAAADLO+yjuBIAALgSAAAlAAAAAAAAAAAAAACkgTepAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3ltYm9sLmpzUEsBAh4DCgAAAAAAAAAAAAwaZb+VCAAAlQgAACUAAAAAAAAAAAAAAKSBMrwDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90YWdnZWQuanNQSwECHgMKAAAAAAAAAAAACqJl1/wLAAD8CwAAKQAAAAAAAAAAAAAApIEKxQMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAJAAAAAAAAAAAAAAApIFN0QMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAOz6g9STCQAAkwkAACEAAAAAAAAAAAAAAKSB2dIDAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAADGbsRe9AIAAPQCAAAqAAAAAAAAAAAAAACkgavcAwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvc3JjL2lzLXByb21pc2UuanNQSwECHgMKAAAAAAAAAAAASLuyqBcTAAAXEwAAKQAAAAAAAAAAAAAApIHn3wMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9tZW1vLXJhY2UuanNQSwECHgMKAAAAAAAAAAAAp4cMZ3oHAAB6BwAANAAAAAAAAAAAAAAApIFF8wMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc1BLAQIeAwoAAAAAAAAAAAAEusOTSgEAAEoBAAAlAAAAAAAAAAAAAACkgRH7AwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAMLX9K+kBgAApAYAACYAAAAAAAAAAAAAAKSBnvwDAEBvY2FwL25vZGVqcy12MC4wLjAvc3JjL3ZhdHMvb2xsYW1hLmpzUEsFBgAAAAAtAC0A6w4AAIYDBAAAAA==","endoZipBase64Sha512":"34e50077d37b65c6e3bfc678b8b285401bedfeaaa802aef4dd443936f4e23da125117086b6a814cf177309e00179ecf842e18fcbae91bfb65f29abdb02575805"} \ No newline at end of file diff --git a/packages/nodejs/src/vats/ollama.js b/packages/nodejs/src/vats/ollama.js index 448f8844b..67130127e 100644 --- a/packages/nodejs/src/vats/ollama.js +++ b/packages/nodejs/src/vats/ollama.js @@ -6,34 +6,34 @@ const DEFAULT_MODEL = 'deepseek-r1:1.5b'; /** * Build function for the LLM test vat. * - * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} vatPowers - Special powers granted to this vat. + * @param {() => Promise} vatPowers.chat - A method for awaiting chat results from an LLM. * @param {unknown} parameters - Initialization parameters from the vat's config object. * @param {unknown} _baggage - Root of vat's persistent state (not used here). * @returns {unknown} The root object for the new vat. */ -export function buildRootObject(_vatPowers, parameters, _baggage) { +export function buildRootObject(vatPowers, parameters, _baggage) { const model = parameters?.model ?? DEFAULT_MODEL; - console.log(`[LLM] buildRootObject "${model}"`); + const prompt = parameters?.prompt ?? `Say hello.`; - let content; + console.log(`[LLM] buildRootObject "${JSON.stringify({model, prompt, vatPowers})}"`); - const prompt = parameters?.prompt ?? `Say hello, ${model}.`; + const { chat } = vatPowers; return Far('root', { - async bootstrap(vats) { - console.log('bootstrap', { model, prompt }); - const ollama = (await import('ollama')).default; - await ollama.pull({ + bootstrap(_) { + chat({ model, + messages: [{ role: 'user', content: prompt }], + }).then((response) => { + console.log('response:', response); + return undefined; + }).catch((problem) => { + console.error('problem:', problem); }); - const response = await ollama.chat({ - model, - messages: [{ role: 'admin', content: prompt }], - }); - content = response.message; }, - async chat() { - return content; + hello(from) { + console.log(`hello, ${from}`); }, }); } diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index 4e085473e..95cc2de98 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -62,8 +62,14 @@ describe('Kernel Worker', () => { ollama: ollamaVatConfig, }, }); + const [vatId,] = kernel.getVatIds(); + console.log('vatId', vatId); + await kernel.sendMessage(vatId, { + method: 'ping', + params: null, + }); expect(true).toBe(true); - }); + }, 30_000); /* it('launches a vat', async () => { diff --git a/yarn.lock b/yarn.lock index cdf354b35..b9a2d5d21 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2213,6 +2213,7 @@ __metadata: eslint-plugin-n: "npm:^17.11.1" eslint-plugin-prettier: "npm:^5.2.1" eslint-plugin-promise: "npm:^7.1.0" + ollama: "npm:^0.5.12" prettier: "npm:^3.3.3" rimraf: "npm:^6.0.1" ses: "npm:^1.9.0" From e3a54453bde489af0179c5af1e2f48ba7ee9029a Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 3 Feb 2025 12:34:09 -0600 Subject: [PATCH 31/55] add vatPower maker to kernel --- packages/kernel/package.json | 1 - packages/kernel/src/VatSupervisor.ts | 44 +++++----------------------- 2 files changed, 7 insertions(+), 38 deletions(-) diff --git a/packages/kernel/package.json b/packages/kernel/package.json index c04392528..b07a41c1d 100644 --- a/packages/kernel/package.json +++ b/packages/kernel/package.json @@ -58,7 +58,6 @@ "@ocap/errors": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", - "ollama": "^0.5.12", "ses": "^1.9.0", "setimmediate": "^1.0.5" }, diff --git a/packages/kernel/src/VatSupervisor.ts b/packages/kernel/src/VatSupervisor.ts index 46170d89a..05aa91e56 100644 --- a/packages/kernel/src/VatSupervisor.ts +++ b/packages/kernel/src/VatSupervisor.ts @@ -23,14 +23,13 @@ import type { VatConfig, VRef } from './types.js'; import { ROOT_OBJECT_VREF, isVatConfig } from './types.js'; import { waitUntilQuiescent } from './waitUntilQuiescent.js'; -import { Ollama } from 'ollama'; - const makeLiveSlots: MakeLiveSlotsFn = localMakeLiveSlots; type SupervisorConstructorProps = { id: string; commandStream: DuplexStream; makeKVStore: MakeKVStore; + makePowers?: () => Promise>; }; const marshal = makeMarshal(undefined, undefined, { @@ -55,6 +54,9 @@ export class VatSupervisor { /** Capability to create the store for this vat. */ readonly #makeKVStore: MakeKVStore; + /** An initialization routine for powers bestowed to this vat. */ + readonly #makePowers: () => Promise>; + /** Result promises from all syscalls sent to the kernel in the current crank */ readonly #syscallsInFlight: Promise[] = []; @@ -66,10 +68,11 @@ export class VatSupervisor { * @param params.commandStream - Communications channel connected to the kernel. * @param params.makeKVStore - Capability to create the store for this vat. */ - constructor({ id, commandStream, makeKVStore }: SupervisorConstructorProps) { + constructor({ id, commandStream, makeKVStore, makePowers }: SupervisorConstructorProps) { this.id = id; this.#commandStream = commandStream; this.#makeKVStore = makeKVStore; + this.#makePowers = makePowers ?? (async () => ({})); this.#dispatch = null; Promise.all([ @@ -203,40 +206,7 @@ export class VatSupervisor { const kvStore = await this.#makeKVStore(`[vat-${this.id}]`, true); const syscall = makeSupervisorSyscall(this, kvStore); - - // XXX We pull the model in the VatSupervisor. This is definitely not how this should be done, - // perhaps not even in this proof of concept. - const DEFAULT_MODEL = 'deepseek-r1:1.5b'; - const ollama = new Ollama({ - host: 'http://localhost:11434', - }); - - const ollamaPull = async (model: string) => { - console.log(`downloading ${model}...`) - let currentDigestDone = false - const stream = await ollama.pull({ model: model, stream: true }) - for await (const part of stream) { - if (part.digest) { - let percent = 0 - if (part.completed && part.total) { - percent = Math.round((part.completed / part.total) * 100) - } - process.stdout.write(`${part.status} ${percent}%...`) // Write the new text - if (percent === 100 && !currentDigestDone) { - console.log() // Output to a new line - currentDigestDone = true - } else { - currentDigestDone = false - } - } else { - console.log(part.status) - } - } - } - - await ollamaPull(DEFAULT_MODEL).catch(console.error); - - const vatPowers = { chat: ollama.chat.bind(ollama) }; // XXX should be something more real + const vatPowers = await this.#makePowers(); const liveSlotsOptions = {}; // XXX should be something more real const gcTools: GCTools = harden({ From e55ea58cbd980cb51ec08044a61d9c714e80e2bc Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 3 Feb 2025 12:36:30 -0600 Subject: [PATCH 32/55] yad --- packages/nodejs/package.json | 8 + packages/nodejs/scripts/call-ollama.js | 56 +- packages/nodejs/scripts/test-llm-ci.sh | 26 - packages/nodejs/src/demo/rag/README.md | 16 + packages/nodejs/src/demo/rag/SETUP.md | 67 ++ packages/nodejs/src/demo/rag/run.ts | 32 + .../nodejs/src/demo/rag/subclusterConfig.ts | 62 ++ .../nodejs/src/demo/rag/vats/ollama.bundle | 1 + packages/nodejs/src/demo/rag/vats/ollama.js | 57 ++ packages/nodejs/src/demo/rag/vats/user.bundle | 1 + packages/nodejs/src/demo/rag/vats/user.js | 38 + packages/nodejs/src/demo/rag/vats/wiki.bundle | 1 + packages/nodejs/src/demo/rag/vats/wiki.js | 29 + .../src/demo/rag/wiki/ambient-authority.txt | 61 ++ .../demo/rag/wiki/confused-deputy-problem.txt | 67 ++ packages/nodejs/src/vat/vat-worker.ts | 17 + packages/nodejs/src/vats/ollama.bundle | 1 - packages/nodejs/src/vats/ollama.js | 39 - packages/nodejs/test/llm/ollama-demo.test.ts | 66 -- packages/nodejs/tsconfig.json | 4 +- yarn.lock | 902 +++++++++++++++++- 21 files changed, 1401 insertions(+), 150 deletions(-) delete mode 100755 packages/nodejs/scripts/test-llm-ci.sh create mode 100644 packages/nodejs/src/demo/rag/README.md create mode 100644 packages/nodejs/src/demo/rag/SETUP.md create mode 100644 packages/nodejs/src/demo/rag/run.ts create mode 100644 packages/nodejs/src/demo/rag/subclusterConfig.ts create mode 100644 packages/nodejs/src/demo/rag/vats/ollama.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/ollama.js create mode 100644 packages/nodejs/src/demo/rag/vats/user.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/user.js create mode 100644 packages/nodejs/src/demo/rag/vats/wiki.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/wiki.js create mode 100644 packages/nodejs/src/demo/rag/wiki/ambient-authority.txt create mode 100644 packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt delete mode 100644 packages/nodejs/src/vats/ollama.bundle delete mode 100644 packages/nodejs/src/vats/ollama.js delete mode 100644 packages/nodejs/test/llm/ollama-demo.test.ts diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 8a3f683f9..d9049b92b 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -25,6 +25,7 @@ "build:docs": "typedoc", "changelog:validate": "../../scripts/validate-changelog.sh @ocap/nodejs", "clean": "rimraf --glob './*.tsbuildinfo' ./.eslintcache ./coverage ./dist", + "demo:rag": "node ./dist/demo/rag/run.mjs", "lint": "yarn lint:ts && yarn lint:eslint && yarn lint:misc --check && yarn constraints && yarn lint:dependencies", "lint:dependencies": "depcheck", "lint:eslint": "eslint . --cache", @@ -69,6 +70,7 @@ "node-gyp": "^11.0.0", "prettier": "^3.3.3", "rimraf": "^6.0.1", + "tsx": "^4.19.2", "typedoc": "^0.27.6", "typescript": "~5.5.4", "typescript-eslint": "^8.8.1", @@ -79,13 +81,19 @@ "node": "^20 || >=22" }, "dependencies": { + "@endo/eventual-send": "^1.3.0", "@endo/marshal": "^1.6.2", "@endo/promise-kit": "^1.1.6", + "@huggingface/transformers": "^3.3.2", + "@langchain/core": "^0.3.37", + "@langchain/ollama": "^0.1.5", + "@langchain/openai": "^0.4.2", "@ocap/kernel": "workspace:^", "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", "better-sqlite3": "^11.7.2", + "langchain": "^0.3.15", "ollama": "^0.5.12", "ses": "^1.9.0" } diff --git a/packages/nodejs/scripts/call-ollama.js b/packages/nodejs/scripts/call-ollama.js index 05c3180d5..206520f47 100644 --- a/packages/nodejs/scripts/call-ollama.js +++ b/packages/nodejs/scripts/call-ollama.js @@ -1,5 +1,46 @@ +import { readFile } from 'fs/promises'; import ollama from 'ollama'; +async function streamResponse(response) { + const thinkEndToken = ''; + const thinkLabel = 'OLLAMA Thought'; + const thinkingDots = ['.', '..', '...']; + const dotInterval = 400; + let thinkingDotsIndex = 0; + let thinking = true; + let accumulatedContent = ''; + const thinkingInterval = setInterval( + () => { + process.stdout.clearLine(); + process.stdout.write(`OLLAMA Thinking${thinkingDots[thinkingDotsIndex]}\r`); + thinkingDotsIndex += 1; + thinkingDotsIndex %= thinkingDots.length; + }, + dotInterval, + ); + console.time(thinkLabel); + for await (const part of response) { + accumulatedContent += part.message.content; + if (thinking) { + if (accumulatedContent.includes(thinkEndToken)) { + process.stdout.clearLine(); + console.timeEnd(thinkLabel); + const tail = accumulatedContent.split(thinkEndToken)[1]; + process.stdout.write(`OLLAMA Response: ${tail}`); + clearInterval(thinkingInterval); + thinking = false; + } + } else { + process.stdout.write(part.message.content); // Write each part of the response to the console + } + } +} + +const getFileContent = async (path) => { + const resolvedPath = new URL(path, import.meta.url).pathname; + return (await readFile(resolvedPath)).toString(); +} + /** * The main function for the script. * @@ -17,7 +58,6 @@ async function main({ model, prompt }) { await ollama.pull({ model }); console.log('USER:', prompt); - process.stdout.write('OLLAMA: '); const response = await ollama.chat({ model, // Specify the model you want to use @@ -26,16 +66,20 @@ async function main({ model, prompt }) { `You are an instance of LLM model ${model}.`, `Respond to user requests ${'respectfully'} and ${'informatively'}.`, ].join(' ')}, + { role: 'admin', content: [ + 'The following is the raw content of the wikipedia page titled "ambient authority".', + await getFileContent('./ambient-authority.txt'), + ].join('\n\n')}, + { role: 'admin', content: [ + 'The following is the raw content of the wikipedia page titled "confused deputy problem".', + await getFileContent('./confused-deputy-problem.txt'), + ].join('\n\n')}, { role: 'user', content: prompt } ], // The message to send stream: true // Enable streaming }); - let accumulatedContent = ''; - for await (const part of response) { - accumulatedContent += part.message.content; - process.stdout.write(part.message.content); // Write each part of the response to the console - } + await streamResponse(response).catch(console.error); console.log('\n'); // Add a newline after the streaming response } diff --git a/packages/nodejs/scripts/test-llm-ci.sh b/packages/nodejs/scripts/test-llm-ci.sh deleted file mode 100755 index 9663ac166..000000000 --- a/packages/nodejs/scripts/test-llm-ci.sh +++ /dev/null @@ -1,26 +0,0 @@ -#!/usr/bin/env bash - -set -x -set -e -set -o pipefail - -# force build sqlite3 so it aligns with node version -yarn build:e2e - -# We borrow the vat definition from extension for now -yarn ocap bundle "./src/vats" - -# Start the server in background and capture its PID -yarn ocap serve "./src/vats" & -SERVER_PID=$! - -function cleanup() { - # Kill the server if it's still running - if kill -0 $SERVER_PID 2>/dev/null; then - kill $SERVER_PID - fi -} -# Ensure we always close the server -trap cleanup EXIT - -yarn test:llm diff --git a/packages/nodejs/src/demo/rag/README.md b/packages/nodejs/src/demo/rag/README.md new file mode 100644 index 000000000..8b42503c9 --- /dev/null +++ b/packages/nodejs/src/demo/rag/README.md @@ -0,0 +1,16 @@ +# RAG Demo +For this demo, we'll be connecting to a locally hosted LLM over the ollama API. Follow the [setup guide](./SETUP.md) to get your ollama running on `localhost:11434`. + +If you prefer to figure things out yourself, [have at](https://ollama.com/). + +### Start Ocap CLI +From the `@ocap/nodejs` package, run this in one terminal. +```sh +yarn ocap start src/demo/rag/vats +``` + +### Run RAG Demo +And then run this in another terminal. +```sh +yarn demo:rag +``` diff --git a/packages/nodejs/src/demo/rag/SETUP.md b/packages/nodejs/src/demo/rag/SETUP.md new file mode 100644 index 000000000..e63074e92 --- /dev/null +++ b/packages/nodejs/src/demo/rag/SETUP.md @@ -0,0 +1,67 @@ +# Setup +The [demo](./README.md) uses a local large language model. This guide will help you install one. + +If you are on a Mac, use the MacOS instructions to get automatic GPU integration via the ollama app. Docker won't connect to the GPU on a Mac. + +Otherwise, use the Docker instructions, and consider the NVIDIA container setup to get GPU integration. + +We'll be using the deepseek-r1 model, which comes in several brain sizes. +- For a weak workstation, try the smallest brained `1.5b` +- For a MacBook Pro type machine try `7b` +- If you have a beefier machine you might try bigger brain models. + +## MacOS +### Download Ollama +Get the [ollama app](https://ollama.com/download/mac) and use it to install the ollama CLI. + +### Pull DeepSeek-R1 +For a MacBook you might try the 7B, but you can do 1.5B if you're light on space. + +Smol brain: +```sh +ollama pull deepseek-r1:1.5b +``` + +Mid curve: +```sh +ollama pull deepseek-r1:7b +``` + +## Docker +### Get Docker +If you aren't familiar, you can just download the [desktop version](https://docs.docker.com/desktop/). + +### Pull Ollama +If you downloaded the desktop version, search 'ollama' and pull the `ollama/ollama` image. + +Or run this in your terminal. +```sh +docker pull ollama/ollama +``` + +### Start Ollama Container +You can just run things. +```sh +docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama +``` + +### Pull DeepSeek-R1 +Smol brain: +```sh +curl -X POST http://localhost:11434/api/pull -d '{"model": "deepseek-r1:1.5b"}' +``` + +Mid curve: +```sh +curl -X POST http://localhost:11434/api/pull -d '{"model": "deepseek-r1:7b"}' +``` + +### Local Llama on a GPU +Peep the [ollama docs](https://github.com/ollama/ollama/blob/main/docs/docker.md) if you want to dock your local llama on a GPU. + +# Check Your Llama +At this point, if you open a browser and navigate to `localhost:11434` you should see the following message. +``` +Ollama is running +``` +If you do, you're ready for the [demo](./README.md)! diff --git a/packages/nodejs/src/demo/rag/run.ts b/packages/nodejs/src/demo/rag/run.ts new file mode 100644 index 000000000..8afae264d --- /dev/null +++ b/packages/nodejs/src/demo/rag/run.ts @@ -0,0 +1,32 @@ +import '@ocap/shims/endoify'; + +import { Kernel } from '@ocap/kernel'; +import { + MessageChannel as NodeMessageChannel, +} from 'node:worker_threads'; + +import { makeKernel } from '../../kernel/make-kernel.js'; +import { makeConfig } from './subclusterConfig.js'; + +const ollamaOnline = async () => { + const response = await (await fetch('http://localhost:11434')).text(); + const expectation = 'Ollama is running'; + if (response !== expectation) { + throw new Error('Ollama not running', { cause: response }); + } +} + +main().catch(console.error); + +/** + * The main function for the demo. + */ +async function main() { + await ollamaOnline(); + // We don't talk to the Kernel via a console (yet) + const kernelPort = new NodeMessageChannel().port1; + const kernel: Kernel = await makeKernel(kernelPort); + const subclusterConfig = await makeConfig('deepseek-r1:1.5b'); + console.log('clusterConfig', JSON.stringify(subclusterConfig)); + await kernel.launchSubcluster(subclusterConfig); +} diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts new file mode 100644 index 000000000..f5b2b3d96 --- /dev/null +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -0,0 +1,62 @@ + +import { TextLoader } from "langchain/document_loaders/fs/text"; +import type { ClusterConfig } from "@ocap/kernel"; +import { readFile } from "fs/promises"; +import { join } from "path"; +import type { Document } from '@langchain/core/documents'; +import type { Json } from "@metamask/utils"; + +type ModelSize = '1.5b' | '7b' | '8b' | '14b' | '32b' | '70b' | '671b'; +type Model = `deepseek-r1:${ModelSize}`; + +const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; + +/* +// XXX Todo: RAG in a separate vat, with introduction at bootstrap time. +const getWikiContent = async (path: string) => { + const resolvedPath = new URL(join('wiki', path), import.meta.url).pathname.replace(/\/dist\//, '/src/'); + const loader = new TextLoader(resolvedPath); + return await (await loader.load()).map((document) => ({ + metadata: { source: path }, + pageContent: document.pageContent, + })); +} +*/ + +export const makeConfig = async ( + model: Model, + verbose: boolean = false, +): Promise => ({ + bootstrap: 'user', + vats: { + // The LLM vat with the special ollama vat power. + ollama: { + bundleSpec: makeBundleSpec('ollama'), + parameters: { model, verbose }, + }, + /* + // A mock wikipedia API which returns the content of a few wikipedia pages. + wiki: { + bundleSpec: makeBundleSpec('wiki'), + parameters: { + docs: [ + ...await getWikiContent('ambient-authority.txt'), + ...await getWikiContent('confused-deputy-problem.txt'), + ], + }, + }, + */ + // The bootstrap vat representing a user action. + user: { + bundleSpec: makeBundleSpec('user'), + parameters: { + prompt: [ + 'Describe the confused deputy problem.', + 'Then, define "object capability model" (OCAP).', + 'Finally, explain how OCAP solves the confused deputy problem.', + ].join(' '), + verbose, + }, + }, + }, +}); diff --git a/packages/nodejs/src/demo/rag/vats/ollama.bundle b/packages/nodejs/src/demo/rag/vats/ollama.bundle new file mode 100644 index 000000000..2352105fb --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/ollama.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"dea8b8f3e8e00a772e54bf4033da12b064495c3a868fc2584944f1993b1ca273f6597ac21378a45c5b71b3b31bf4b15fa1582fa75dbf8f5fab508b23e58ff057"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/ollama.js b/packages/nodejs/src/demo/rag/vats/ollama.js new file mode 100644 index 000000000..755e06d3e --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/ollama.js @@ -0,0 +1,57 @@ +import { E } from '@endo/eventual-send'; +import { Far } from '@endo/marshal'; + +// The default LLM model to use. +const DEFAULT_MODEL = 'deepseek-r1:1.5b'; + +const parseResponse = (response) => { + const thinkTokens = ['', '']; + const [thought, speech] = response.message.content + .substring(thinkTokens[0].length) + .split(thinkTokens[1]); + return { + thought: thought.trim(), + speech: speech.trim(), + }; +}; + +const clip = (content, length = 10) => + `${content.substring(0, length)}${content.length > length ? '...' : ''}`; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} vatPowers - Special powers granted to this vat. + * @param {() => Promise} vatPowers.ollama - An Ollama instance ready for use. + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(vatPowers, parameters, _baggage) { + const model = parameters?.model ?? DEFAULT_MODEL; + const { verbose } = parameters; + const { ollama } = vatPowers; + + console.debug(`buildRootObject "${JSON.stringify({ model, ollama })}"`); + + return Far('root', { + async chat(prompt) { + if (verbose) { + console.log('chat'); + console.time('llm'); + } + const response = await ollama.chat({ + model, + messages: [ + { role: 'user', content: prompt } + ], + }); + const { thought, speech } = parseResponse(response); + if (verbose) { + console.timeEnd('llm'); + console.debug('Thought:', thought); + } + return speech; + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/vats/user.bundle b/packages/nodejs/src/demo/rag/vats/user.bundle new file mode 100644 index 000000000..5cd17260c --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/user.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAADKe4HZlTsAAJU7AAAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgInRhZ3MiOiBbXSwKICAiZW50cnkiOiB7CiAgICAiY29tcGFydG1lbnQiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAibW9kdWxlIjogIi4vc3JjL2RlbW8vcmFnL3ZhdHMvdXNlci5qcyIKICB9LAogICJjb21wYXJ0bWVudHMiOiB7CiAgICAiQGVuZG8vY29tbW9uLXYxLjIuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vY29tbW9uIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2NvbW1vbi12MS4yLjgiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vY29tbW9uLXYxLjIuOCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL29iamVjdC1tYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAib2JqZWN0LW1hcC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjEwZTA4YzE4NzZiODQzYzFmMDAyNzdmNmQzNGRkYTNiZDkzMjlkZTZhOWYwOTMxMzU4MjAxZjEwMDRjMmYzYTY0MTg5ZjZmZjBlYWJmZjhiYzU2MjRkNDAyYzFlN2M1NzJlNmFhM2JlYmI5MzM4ZjIzNzVmM2Y4MzFhYmEzOGYyIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2Vudi1vcHRpb25zIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQxNzc2ZWViMjFiMWM1NTFkYTNmOWI4ZGNkZjVhYmQ4OGJjYmY1ZjhlMzhjYjA0ZWRhYmM4Y2I5NjRiYjk3NTE4ZmY0Y2FjYjc0M2U4YWJiYWFjMjI4NjE2ODE1ZmJlNDBlODZiZTJkN2Q0MjgxNTc4OTUyZjhhYTg2NmExYjk3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vudi1vcHRpb25zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbnYtb3B0aW9ucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjljZWIxMmRlNmQ2MWE2MzQwNzg1NTI4NmU1ZTEwNzgzYjUyZDUzNGIxNWVlYjY0OWI5ZTU2MWQxMDY3MDc0ODUxOTJlOTc5MTQxYjQyMjU5ZTY0Njk5YjY2MWI4OTNmNDQyNDVkMTFjNGFhYTA3MGUxOTM4NDBmM2I3ZWQxYWU0IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lcnJvcnMtdjEuMi44IjogewogICAgICAibmFtZSI6ICJAZW5kby9lcnJvcnMiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxZmQ0MTdiY2RiZGFlYzY5ZGExYWRkZWJiNTFmNjU5YmI4YjMxNWRjMWM5NmI3ZjcxMTU2YzU1NjJmMTdjZDkxOGNjYTA5ZGJmMDIxMmNjYmUxMWRkOTBhYjMzYTUxYjlkMTllYTMzY2ExOTNkMTY2NTI0ZTczYjMyYmEzNTVjMiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmM5ZDk3ZDA3OTRlYWU4NjhmM2Q2Y2RhYjFkNWNiYjk1ZmU1NjZlYzBhYThmMzFmYzdkNzhlMTBkOTUzNTllYjE2MmQ2NjE4ODIyZWEyMDVkYjUyYzI1ZGZiOTY4MGYxZDA5MGZmYjFmNGE0ZWM4Y2YxYmZhODM1ZjY1ZDZiYjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZXhwb3J0cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXhwb3J0cy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xvY2FsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9sb2NhbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk2YTQ4MWI2M2NjMzQxMDU0NTBhYWI0M2E2ZmJiNDAwYTYyNTdhMDgzN2VjMzMzZDM1ODJkMDIyNDJkYzg1MDgzZWUyYjFkOWZjM2RkMTBjOWEyNDg2MmU1NmUyNDkxODEyY2UxN2ZkMDMzNGM2MWFmNGZiMjA5ZjNmN2Y2YTQzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzc4YmJjYjcxNWVmOTM5ZGZmNjdhNTI2YzlhMGIyMmEwYTMyMDBkMTBjOTczZDhkYzFlZWI5N2NmNTY4NTVlNDk2ZDNiODg0Mjc2NGMyMTRlZGU1MWUxZGJlMjUzNzVkYTAxMjFhNjg4ZjNiOGMxZDFmN2M5YTYzYzE0ZDM2MSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9uby1zaGltLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9uby1zaGltLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGFjNWNiYjQ0N2NjNTk5ZDUxYTk2NGUyODVlMjljMDliYmI5MDdkNzJhYjY1MzNhMmQ5MzJmNTFjYzc4NWMwY2ZmOTMwMDNjNWJmNWRiMTE2MWQzNWMzY2ZhM2JmNTJhNGI4OGM4NjVjZTVmYjg0ZjU4MzIzNjczNWJmNWFiMjgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHJhY2stdHVybnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RyYWNrLXR1cm5zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2IwMjE3N2Y1NDVmNWE2Y2ExNDRiOGVhM2M4MzJjODk4NzExZThlYTJjZjU0Mzk1OWY1YTViYjcxMjRlNWYwNDdlNDljMDFkOGY1MThkNThkMDAzY2ZhZDQyODY3NGRjNDVkNWY1MTBlNGE0ZjRiNTE0ZGNkNWE3NTFjM2U1NmYiCiAgICAgICAgfSwKICAgICAgICAiLi91dGlscy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJ1dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImZlYTA0MTFiMjE2YzcxNDE1MTQzOTY2NjRmOGY4MjEzYWNkMTEyZTkzMGMwZjRmYWMwMzQyN2Y1NzM3ZDczN2QwZTk0NmI2Y2M0YzYwODg0ZDA0MDU3Yjc3Zjg4MDhhMzk2NzM2ODU5NTU4ODcyNDM1ZWFlZWVkMmYxMzI2NDdkIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9tYXJzaGFsLXYxLjYuMiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbWFyc2hhbCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jb21tb24tdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9vYmplY3QtbWFwLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Vycm9ycyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY1LjAuMTMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5NzFhNGJhZjkyYjU0OGUyNDc0ODgwYzA3ZGFiZjM2MWYyZmQwMzhjNDAwZGE1MWQwYTQ0NjgwOTJlMzY1NTU3Njk3YzhlYjFjYWUzMjVjZmQ5ZmFmNzJhYjg2YzEzZjA0MjQwYTZlMTQ3M2E3ZTM5Mzg2MmRkMDQxMWI1NGUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVBhc3NhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjBkYWNmYTE3YTA1ZmU0M2IwY2FkY2QxODYzMGRiZjU4NmJkMjRkYTQ0YTc4ODU5MDAyNTUxMWVkOGRlZmEwZjEyOWQ3YjI0M2I1YjljZjA2MzAzZTQxNGNlN2I3NzZmOTA4NzgwZDE1NGJkOTI4NTU3MDFhOTgyMGQxMWQ5MWIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb0NhcERhdGEuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlMjEzNzVlYzUxNGEyYjAxMDVjYzJmYmRlY2IzNWJiNTE5OWIyMmZmZjY5MjkwOWIzNGM4NGJmYzE2ZDc5OTBlZjVkMzQyY2I1ZjAyYzZhMzI1N2IwN2E4Y2EzNjJjNmEyMzE1MjJiODg5ZjgxZDQ2ODVhNDYwN2ZiZDg0OTcwYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlVG9TbWFsbGNhcHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNTU4Y2EwZTNhOTcwZjQzZWRlYzdhOTY5NTA2YmQ4MWU0ZDllZmNkOWVlZGFjZDg3NDcyZTFmYzQ1ZDAyMmFlZDAzZjcxMmJjYTUxYTJkN2VjMTQ5MjllNWZlMDg4MjM2NDM3OTIwNDEzYjM1Y2EwZjk4NTdlZjExODE2ZmNmNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1qdXN0aW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2ZTQxOTY2OWYyN2RmMjI1MWUwMWNlMTU4NmVkYzVmNzI0YjNjNjgxOTM5MzE2NjA2ZDU0OWRmY2ZjOTllMDk2MjZjMTllNDY3MGY0ZDc1MmM3OTRiMGYxOTczOTFjYzBiZDM3NTdjYzNkYWVkZGE5NzJkN2Y0NTY4MmQzZWYxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0NGNmNmRiZWY1MzliYjQ5YTdhZTFlODkzZGZmNGVlYmQ4NWJmNzE4MTdhZDczODg1YzUxMmY4NjBhZWFmOTJlNzQ3ZWZlMzg2N2ExZjg4YzY4YTFiMmYwMjc5YjRiNmE0MjQzMWYwNWMzNWEzNTdhM2ZlMzdhNjRjMTY1YmQzOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYTdlMzgxYjcxNDBkNTM5Y2U2Yjg0NThlYWU3ZTcyZjM4ZTUyNDgxMjhhYmYyMWU5ZjU2OGI1NDY0ODlhMjYzY2JkYWNhMmIzNGE0NTcxNDgyNzA4OWI3NDk3MzgwZDNhYTA2NjY5YjVkZGE3NjhkMzljODE5YjhkODdlM2NlYzgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmFua09yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yYW5rT3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwOTY2MzNlODZjMDk2ZmYzMjhlMjM0NDJmYWU0ZWVhZWJkNjlmNDhlODQzM2RkOTlkODU0YmJkOGI3MDM3YzgzNjM0MmRiNjI4OTYzYWFjYTE5YzIxNzIwMTViNjhjZjk5MWJmMTRiMTVhM2IwOWYzM2YwMGEzZDI0ZWJlZTEyNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1NDY1NWU4NTkzMTk4ODQ3MGJkZGFiMWZlZjU1NmVmOGJmYjdlMjYyNTBiNmVlZTQ1NTYwZDgwZWQxZTNlZjhkNWJiOGU1ZDA1OGI2MDg1ZWNlMmUxN2FmMjE2ZDgzYWE5MzkwNzBlNGUyYzE5NTI1ODk4NmI3MzYwOTlmYWQ5YyIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vbmF0LXY1LjAuMTMiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL25hdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzQyZTI2NjMyYmJhYjRiYzhmNTkxN2Q3MmYwNzQyM2MxNjI2NGYyZDZhMjBmNmRlOGQxODk2NjZhM2VmMTk2NjhiNmJkNTdlZTYzODM1MmY4OGQ5YzY5Mjk5OGFmZTY4YjUxM2E4YzMzYmY2ODJkODZhZmUwM2ExZTEzYTdlYiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Bhc3Mtc3R5bGUiLAogICAgICAibGFiZWwiOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9lcnJvcnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdXRpbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5MzJkNTRmNWI0MWFjN2IyNDFiMDQ0N2RlYmI1Zjc5MzU5YTRjYWM1MmQ3Y2I2ODQ1NTRkMjUxNTE5OWI5OWE0NWYwMWZlYzkyYWNhNDdhYTViNzE1OWU0ZWRiOTRhYzdjYzRiMWJhODYxNWIyMzk0NDI4ODFlZDg5MGZlMTUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29weUFycmF5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5QXJyYXkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMTk4YTI4ODUyYjRjYTM2OGJmODdmYTg0ZDcwYmM3YmNmOTUwZGM1Y2Y2MzUyYWY2YzFhOTg3YzE2ZTc3NDkxMDQ4NTFhNDUyMGMxZjMyNzZiZDk1ZDIwZGEyNzU4ZTRhNDM0MWUwOTI4NjQ4YzlmY2QzOTBjNDRhZGMyMjQ0MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb3B5UmVjb3JkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5UmVjb3JkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmExMTgzYzI4ZmU1N2MyNjM3MmZhNWI5NDRhMzg1NzZkNWRhNmQ5MzIwYWZmNzY0YWFlODkxNjRhNWEwNGE1NzNmYWI5ZGRiOWY2YzJjZTk2NWUxMjFkYmRmYWNkYWM0MzE0NDMzOWUzODM4MzY4YzkyMWI0YjY3YTNlZjgzOTgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9kZWVwbHlGdWxmaWxsZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5MDY3Yjc1OWYyNGQ0OWEzOTc4Y2M5NGQzMDZiNjJlZDFlZmQyM2M3NmU0YzFhMjI2NDhjMzVhN2NkMjcxZTg1ZTYzZGNmNTNhZjdmNWZhMjA3YjNlMzQ5YjgwNTdkYzBjMjM5OTcwNjgwNTNlZmE5YzZmYzY5N2Q0YzBlNWQzYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lcnJvci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXJyb3IuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyNGViNDFhZmI3OTc2YmI3YTNmNDVkMjk1NGVlY2FhNWEzMzIwN2ZmMzBiNjhmMGEzZDcxZGJkNWY0ZWU1MDQ1ZTg4NzA4MmY1OGYwNDM2MTgxOTZkMzA5YjFlNTUyNTMxMjVlMjBiYmRiMjJmYTAyNzgyYTE0ZWRjM2JlNGZmMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pdGVyLWhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2l0ZXItaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdlNGM5NjA4ZDE1ZDYzYTdjYzc1ODIyYWE3MGRiNGE3NzMwZjMyZTBjYzZhYTRiZDNiOTAwYjA1Mjk4ZTU3YjE1NTljOTY1YjU0OTJlNGE4NWY4YTIwYTc2N2RmZjJlMTcwNThkMDg3NTEzYzY4NTI2MGY0NWNmOTJiYjIwY2RjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2UtZmFyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYWtlLWZhci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjUyNmU2OTgxMzc1MjE4ZDA3YmZlNWMzYjhjMjg3ZGMyMDVlYTBkNTU5NjRjYmMyMWJjYWZiNzMxOWE2YTg5MGRkNTU1M2ViZmRjN2EzMjM2MTQxYTFkNzVlNzVhOTcyOGUwMzUyZTc2NTU0N2E0NDI3OWE1ZGNmN2EzYjVlYzU3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2VUYWdnZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2VUYWdnZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4YTU3ZjRmMTg3MTE0NjhkODFlMzBlODJiYzYwZTQ3MDQyMDI2ODFmMjY5NGFkM2IwNzUzY2IzYmQyMWNmOWQ0OWQ3OGYyNzliYWU0ZjlkMTI5Njg3MzJkNDYxOTU1ODZkOTcyNzNhZGFmNGQ3NmY4ZWJmNDA4MjQyM2IwMTgxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNGJmMmNkNjVlYTI1NGVlYjMyZWQ4MDI5ZTEzNTBkOGE4MTJiM2EzM2VkMGMyYzkxYzcxZDhjNzRhOTlmYWZhM2UwMjIwMTAzZjY5NWIwN2RiMTYxMjI3YWJhNjNhMWE5YWIwNzU4N2M0NTNhNThhMDA5Yjk0NWQ0MjFmZTJiMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGVPZi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlT2YuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjYTI3NTA3YzU4MjhmMzQ3ZWFmMmYyNzVkNjY5NzEyNDVlYmUyZGRlNjk0NjMwODJjMjE1ZTc3ZDAyNjZmZThmZjBjYTA4MTQwZjk4ZTljNDIyYTAxNjJlNjc3MTE3YzkwNGM5MzczNzRiNmUzNTNiYjVhODA3NzU1MGEzZTQwMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yZW1vdGFibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JlbW90YWJsZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc0MWU1ODdkYmJmNTY4OTRhMDFmNzdhMmNlM2RmOTBmZGQ5MmNjN2RiMDExMDY0MmY5NDY0NGQ2NTRhZTI3MmIzZTRmZjFkODEwNGMzZWI5NmIxMzI0ODg3YzdkNjhiMzQxNjEyODI3ZDAzMTQxOGU5OGI3NjM0Y2M5MDE0M2VkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3NhZmUtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc2FmZS1wcm9taXNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjE4YjZmYWJlODY3MzRmMWU5ZTEwZTkyMjA1MWY3MGYyMzY4ODFiMWZlODg5YjI2MTQ1OTY4ZjBiYThiNmQ4ZGEwZTAyMjk4MDk5ZGY2OGM1YzA1MjViZGY5NDUwYTkyOTdkM2Q5MjY3ZjczNjk2NDIwOGJkYzM5YTAwNjNlMjciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RyaW5nLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zdHJpbmcuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNWY4ZjYwZGEzNzVjNGRkNTQ1YWY2MTEwYzY2OWM0MDI0ODI2YzIwZWIxYWU4ZDkyYTNiMDEyNzVjN2Q2Y2VhM2RhZDZiOTI0MjVlNjAzZTQ2NzczZWM3MzA2NTM1OWE2MThjNTdlYWJiMTVlNWZhOTA5MWNmYjJkMDMxNjEwZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zeW1ib2wuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N5bWJvbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImM1Mzc0MDgxNDdhNzIzOGRlZDFjMzczZTZlZTZiYWYzNDNkYTdkMmM0YzU5NTJmMjMwMjU2MDFlNThlNTdmMjJiMzI1OWZhMDIyYWNlNjk0YjVjMjg5MDY3ZGIxZmZkZmQyMjk2NDJmYzBiMzlkOTcxNmJmZmE5MGVmMjJkZjBkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdGFnZ2VkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjU3NWQxNDUxZjQ3ZWIzZDg4YzU0MzVkZTE5NGUwZjc2M2Q3NDc2M2EzMzE3YzNhYTE1Zjc2ZjQ1MjQzY2E5MTA2NmViYzk2YWYxZTk3MjA0MDNkYWVlZmRiMjU4NmY3MzFiZWVhMjM0MzBmMDg3Njc3ZDQzZjFlM2RjNWMyZjAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5YzdhOWM0NGUxY2MxNmM1Nzg1N2NjNzJkZjgxMWY5YjZjMjZlYzllNjMwZDhiYjEzMWFiYmU4NWUyZjQ3OWQxMTJhNDU0N2YyNDAxNzk0Nzg2MTNjZjk3ZTQ1NDE4MzAwN2FjNTQ4MDBiMWE4ZDU2MTc4ZjE4ODBlYWMwNWE2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Byb21pc2Uta2l0IiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImFmNDk2MmU0ODNkODRjODdmZDliNzk1ZDdkM2ViYzRkZTIwM2Y5NGQ1MDQxODhjY2VmNDFmZjA5ZGUwYmVmNTI1NDNmNGYzMTNjYTE5ZWMxN2ZjYzRiOGNkODg3NzhhYWQ2ZjY0YzgxMDFkODM3NDc4ZDhiNTk0YTEwNjZjOTdjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2lzLXByb21pc2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2lzLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NzczMTVhNTE2MjM1YTAyMDQ4YjNjNGRmMTA3MWM4YmYxZjFkZTkwM2Q0Y2U4YTkyYzk1OGUxZTBjNzI2NGVkZDIyZjU3NjE5OWYyZjEzOWViMWZkNjI3MDVhODUzNmU3NTAyZTM4ODZjYTNmNWYyODkzMTI0YmU4M2E0YzlhNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tZW1vLXJhY2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lbW8tcmFjZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY0ZWZjOGY0ZGE2MDBhMzEyNmQyN2NkNTBhYjAxNzAyNTAzMGMyZjI0Yzk5YWExODFiNTJhODRkZDEzNGIxODcxNjkxMzVlNjZlZjJlYjYzNjMwYmVmNzYwNzQ4MzM3NzdjNDUzMGYyM2E5NDdhMzNkYzg1MDMyN2YxNTQzOGNlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjRlMmM0YjVjZGUzOGUxZjQ2ZmNiMDAxYTQyNzQ1YTgyMzIxNDhlNTMxZDc2ZWM5NmE2YWM5NmNhODVlNjE4MDM1MjgyNzE5MzAxNTUzMGU2ZjUyYzQ5NTFjN2Y1NmEzYWRiNjFmNjlmMmM1OWU1NzEyZGE5NjY1MThiMzk3OTc1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAb2NhcC9ub2RlanMtdjAuMC4wIjogewogICAgICAibmFtZSI6ICJAb2NhcC9ub2RlanMiLAogICAgICAibGFiZWwiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAb2NhcC9ub2RlanMtdjAuMC4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MS42LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlbW8vcmFnL3ZhdHMvdXNlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGVtby9yYWcvdmF0cy91c2VyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODE1MjI1MzAwNGUwYWZkOWM4ZTEzZDYwMmNhYWU2ZTI3M2Q0M2I2Nzg1MGE2NWNjYjU5ODZkMDE4ZmE5YTgzMDMzZjVlNDdkMDMyYTUwNDc1YjU3NDMwZDE1ZmRiZTkxOTNmOGY1YjNhNjYwZjZlMjFiNzY4ZGU5YWJjNjUwOTgiCiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9UEsDBAoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAQGVuZG8vY29tbW9uLXYxLjIuOC9vYmplY3QtbWFwLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJvYmplY3RNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIGNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBCeSBhbmFsb2d5IHdpdGggaG93IGBBcnJheS5wcm90b3R5cGUubWFwYCB3aWxsIG1hcCB0aGUgZWxlbWVudHMgb2ZcbiAqIGFuIGFycmF5IHRvIHRyYW5zZm9ybWVkIGVsZW1lbnRzIG9mIGFuIGFycmF5IG9mIHRoZSBzYW1lIHNoYXBlLFxuICogYG9iamVjdE1hcGAgd2lsbCBkbyBsaWtld2lzZSBmb3IgdGhlIHN0cmluZy1uYW1lZCBvd24gZW51bWVyYWJsZVxuICogcHJvcGVydGllcyBvZiBhbiBvYmplY3QuXG4gKlxuICogVHlwaWNhbCB1c2FnZSBhcHBsaWVzIGBvYmplY3RNYXBgIHRvIGEgQ29weVJlY29yZCwgaS5lLixcbiAqIGFuIG9iamVjdCBmb3Igd2hpY2ggYHBhc3NTdHlsZU9mKG9yaWdpbmFsKSA9PT0gJ2NvcHlSZWNvcmQnYC4gRm9yIHRoZXNlLFxuICogbm9uZSBvZiB0aGUgZm9sbG93aW5nIGVkZ2UgY2FzZXMgYXJpc2UuIFRoZSByZXN1bHQgd2lsbCBiZSBhIENvcHlSZWNvcmRcbiAqIHdpdGggZXhhY3RseSB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lcywgd2hvc2UgdmFsdWVzIGFyZSB0aGUgbWFwcGVkIGZvcm0gb2ZcbiAqIHRoZSBvcmlnaW5hbCdzIHZhbHVlcy5cbiAqXG4gKiBXaGVuIHRoZSBvcmlnaW5hbCBpcyBub3QgYSBDb3B5UmVjb3JkLCBzb21lIGVkZ2UgY2FzZXMgdG8gYmUgYXdhcmUgb2ZcbiAqICAgICogTm8gbWF0dGVyIGhvdyBtdXRhYmxlIHRoZSBvcmlnaW5hbCBvYmplY3QsIHRoZSByZXR1cm5lZCBvYmplY3QgaXNcbiAqICAgICAgaGFyZGVuZWQuXG4gKiAgICAqIE9ubHkgdGhlIHN0cmluZy1uYW1lZCBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIG9mIHRoZSBvcmlnaW5hbFxuICogICAgICBhcmUgbWFwcGVkLiBBbGwgb3RoZXIgcHJvcGVydGllcyBhcmUgaWdub3JlZC5cbiAqICAgICogSWYgYW55IG9mIHRoZSBvcmlnaW5hbCBwcm9wZXJ0aWVzIHdlcmUgYWNjZXNzb3JzLCBgT2JqZWN0LmVudHJpZXNgXG4gKiAgICAgIHdpbGwgY2F1c2UgaXRzIGBnZXR0ZXJgIHRvIGJlIGNhbGxlZCBhbmQgd2lsbCB1c2UgdGhlIHJlc3VsdGluZ1xuICogICAgICB2YWx1ZS5cbiAqICAgICogTm8gbWF0dGVyIHdoZXRoZXIgdGhlIG9yaWdpbmFsIHByb3BlcnR5IHdhcyBhbiBhY2Nlc3Nvciwgd3JpdGFibGUsXG4gKiAgICAgIG9yIGNvbmZpZ3VyYWJsZSwgYWxsIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogICAgICBub24td3JpdGFibGUsIG5vbi1jb25maWd1cmFibGUsIGRhdGEgcHJvcGVydGllcy5cbiAqICAgICogTm8gbWF0dGVyIHdoYXQgdGhlIG9yaWdpbmFsIG9iamVjdCBtYXkgaGF2ZSBpbmhlcml0ZWQgZnJvbSwgYW5kXG4gKiAgICAgIG5vIG1hdHRlciB3aGV0aGVyIGl0IHdhcyBhIHNwZWNpYWwga2luZCBvZiBvYmplY3Qgc3VjaCBhcyBhbiBhcnJheSxcbiAqICAgICAgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGFsd2F5cyBiZSBhIHBsYWluIG9iamVjdCBpbmhlcml0aW5nIGRpcmVjdGx5XG4gKiAgICAgIGZyb20gYE9iamVjdC5wcm90b3R5cGVgIGFuZCB3aG9zZSBzdGF0ZSBpcyBvbmx5IHRoZXNlIG5ldyBtYXBwZWRcbiAqICAgICAgb3duIHByb3BlcnRpZXMuXG4gKlxuICogV2l0aCB0aGVzZSBkaWZmZXJlbmNlcywgZXZlbiBpZiB0aGUgb3JpZ2luYWwgb2JqZWN0IHdhcyBub3QgYSBDb3B5UmVjb3JkLFxuICogaWYgYWxsIHRoZSBtYXBwZWQgdmFsdWVzIGFyZSBQYXNzYWJsZSwgdGhlbiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqIGEgQ29weVJlY29yZC5cbiAqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIGFueT59IE9cbiAqIEB0ZW1wbGF0ZSBSIG1hcCByZXN1bHRcbiAqIEBwYXJhbSB7T30gb3JpZ2luYWxcbiAqIEBwYXJhbSB7KHZhbHVlOiBPW2tleW9mIE9dLCBrZXk6IGtleW9mIE8pID0+IFJ9IG1hcEZuXG4gKiBAcmV0dXJucyB7UmVjb3JkPGtleW9mIE8sIFI+fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKFxuKFtrLHZdKT0+LyoqIEB0eXBlIHtba2V5b2YgTywgUl19ICovW2ssbWFwRm4odixrKV0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7UmVjb3JkPGtleW9mIE8sIFI+fSAqL2hhcmRlbihmcm9tRW50cmllcyhtYXBFbnRzKSkpO1xuIH07JGjNj19vbmNlLm9iamVjdE1hcChvYmplY3RNYXApO1xuaGFyZGVuKG9iamVjdE1hcCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJvYmplY3RNYXAiOlsib2JqZWN0TWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUY5zqUAQAAlAEAACEAAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW52LW9wdGlvbnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy9lbnYtb3B0aW9ucy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvZW52LW9wdGlvbnMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAXZuU6h4TAAAeEwAAKwAAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiLCJnZXRFbnZpcm9ubWVudE9wdGlvbiIsImdldEVudmlyb25tZW50T3B0aW9uc0xpc3QiLCJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtY2hlY2sqL1xuXG4vKiBgQGVuZG8vZW52LW9wdGlvbnNgIG5lZWRzIHRvIGJlIGltcG9ydGVkIHF1aXRlIGVhcmx5LCBhbmQgc28gc2hvdWxkKi9cbi8qIGF2b2lkIGltcG9ydGluZyBmcm9tIHNlcyBvciBhbnl0aGluZyB0aGF0IGRlcGVuZHMgb24gc2VzLiovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cbi8qIFByZWx1ZGUgb2YgY2hlYXAgZ29vZCAtIGVub3VnaCBpbWl0YXRpb25zIG9mIHRoaW5ncyB3ZSdkIHVzZSBvciovXG4vKiBkbyBkaWZmZXJlbnRseSBpZiB3ZSBjb3VsZCBkZXBlbmQgb24gc2VzKi9cblxuY29uc3R7ZnJlZXplfT1PYmplY3Q7XG5jb25zdHthcHBseX09UmVmbGVjdDtcblxuLyogU2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gdGhlIG9uZSBpbiBzZXMnIGNvbW1vbnMuanMgZXZlbiB0aG91Z2ggaXQqL1xuLyogdXNlcyB0aGUgb3RoZXIgdGVjaG5pcXVlLiovXG5jb25zdCB1bmN1cnJ5VGhpcz1cbihmbik9PlxuKHJlY2VpdmVyLC4uLmFyZ3MpPT5cbmFwcGx5KGZuLHJlY2VpdmVyLGFyZ3MpO1xuY29uc3QgYXJyYXlQdXNoPXVuY3VycnlUaGlzKEFycmF5LnByb3RvdHlwZS5wdXNoKTtcbmNvbnN0IGFycmF5SW5jbHVkZXM9dW5jdXJyeVRoaXMoQXJyYXkucHJvdG90eXBlLmluY2x1ZGVzKTtcbmNvbnN0IHN0cmluZ1NwbGl0PXVuY3VycnlUaGlzKFN0cmluZy5wcm90b3R5cGUuc3BsaXQpO1xuXG5jb25zdCBxPUpTT04uc3RyaW5naWZ5O1xuXG5jb25zdCBGYWlsPShsaXRlcmFscywuLi5hcmdzKT0+e1xubGV0IG1zZz1saXRlcmFsc1swXTtcbmZvcihsZXQgaT0wO2k8YXJncy5sZW5ndGg7aSs9MSl7XG5tc2c9IGAke21zZ30ke2FyZ3NbaV19JHtsaXRlcmFsc1tpKzFdfWA7XG4gfVxudGhyb3cgRXJyb3IobXNnKTtcbiB9O1xuXG4vKiBlbmQgcHJlbHVkZSovXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogYG1ha2VFbnZpcm9ubWVudENhcHRvcmAgcHJvdmlkZXMgYSBtZWNoYW5pc20gZm9yIGdldHRpbmcgZW52aXJvbm1lbnRcbiAqIHZhcmlhYmxlcywgaWYgdGhleSBhcmUgbmVlZGVkLCBhbmQgYSB3YXkgdG8gY2F0YWxvZyB0aGUgbmFtZXMgb2YgYWxsXG4gKiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQgd2VyZSBjYXB0dXJlZC5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gYUdsb2JhbFxuICogQHBhcmFtIHtib29sZWFufSBbZHJvcE5hbWVzXSBEZWZhdWx0cyB0byBmYWxzZS4gSWYgdHJ1ZSwgZG9uJ3QgdHJhY2tcbiAqIG5hbWVzIHVzZWQuXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW52aXJvbm1lbnRDYXB0b3I9KGFHbG9iYWwsZHJvcE5hbWVzPWZhbHNlKT0+e1xuY29uc3QgY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzPVtdO1xuXG4vKipcbiAqIEdldHMgYW4gZW52aXJvbm1lbnQgb3B0aW9uIGJ5IG5hbWUgYW5kIHJldHVybnMgdGhlIG9wdGlvbiB2YWx1ZSBvciB0aGVcbiAqIGdpdmVuIGRlZmF1bHQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbk5hbWVcbiAqIEBwYXJhbSB7c3RyaW5nfSBkZWZhdWx0U2V0dGluZ1xuICogQHBhcmFtIHtzdHJpbmdbXX0gW29wdE90aGVyVmFsdWVzXVxuICogSWYgcHJvdmlkZWQsIHRoZSBvcHRpb24gdmFsdWUgbXVzdCBiZSBpbmNsdWRlZCBvciBtYXRjaCBgZGVmYXVsdFNldHRpbmdgLlxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZ2V0RW52aXJvbm1lbnRPcHRpb249KFxub3B0aW9uTmFtZSxcbmRlZmF1bHRTZXR0aW5nLFxub3B0T3RoZXJWYWx1ZXM9dW5kZWZpbmVkKT0+XG57XG50eXBlb2Ygb3B0aW9uTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYEVudmlyb25tZW50IG9wdGlvbiBuYW1lICR7cShvcHRpb25OYW1lKX0gbXVzdCBiZSBhIHN0cmluZy5gO1xudHlwZW9mIGRlZmF1bHRTZXR0aW5nPT09J3N0cmluZyd8fFxuRmFpbCBgRW52aXJvbm1lbnQgb3B0aW9uIGRlZmF1bHQgc2V0dGluZyAke3EoXG5kZWZhdWx0U2V0dGluZylcbiB9IG11c3QgYmUgYSBzdHJpbmcuYDtcblxuLyoqIEB0eXBlIHtzdHJpbmd9ICovXG5sZXQgc2V0dGluZz1kZWZhdWx0U2V0dGluZztcbmNvbnN0IGdsb2JhbFByb2Nlc3M9YUdsb2JhbC5wcm9jZXNzfHx1bmRlZmluZWQ7XG5jb25zdCBnbG9iYWxFbnY9XG50eXBlb2YgZ2xvYmFsUHJvY2Vzcz09PSdvYmplY3QnJiZnbG9iYWxQcm9jZXNzLmVudnx8dW5kZWZpbmVkO1xuaWYodHlwZW9mIGdsb2JhbEVudj09PSdvYmplY3QnKXtcbmlmKG9wdGlvbk5hbWUgaW4gZ2xvYmFsRW52KXtcbmlmKCFkcm9wTmFtZXMpe1xuYXJyYXlQdXNoKGNhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcyxvcHRpb25OYW1lKTtcbiB9XG5jb25zdCBvcHRpb25WYWx1ZT1nbG9iYWxFbnZbb3B0aW9uTmFtZV07XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2Ygb3B0aW9uVmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gbmFtZWQgJHtxKFxub3B0aW9uTmFtZSlcbiB9LCBpZiBwcmVzZW50LCBtdXN0IGhhdmUgYSBjb3JyZXNwb25kaW5nIHN0cmluZyB2YWx1ZSwgZ290ICR7cShcbm9wdGlvblZhbHVlKVxuIH1gO1xuc2V0dGluZz1vcHRpb25WYWx1ZTtcbiB9XG4gfVxub3B0T3RoZXJWYWx1ZXM9PT11bmRlZmluZWR8fFxuc2V0dGluZz09PWRlZmF1bHRTZXR0aW5nfHxcbmFycmF5SW5jbHVkZXMob3B0T3RoZXJWYWx1ZXMsc2V0dGluZyl8fFxuRmFpbCBgVW5yZWNvZ25pemVkICR7cShvcHRpb25OYW1lKX0gdmFsdWUgJHtxKFxuc2V0dGluZylcbiB9LiBFeHBlY3RlZCBvbmUgb2YgJHtxKFtkZWZhdWx0U2V0dGluZywuLi5vcHRPdGhlclZhbHVlc10pfWA7XG5yZXR1cm4gc2V0dGluZztcbiB9O1xuZnJlZXplKGdldEVudmlyb25tZW50T3B0aW9uKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5jb25zdCBnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0PShvcHRpb25OYW1lKT0+e1xuY29uc3Qgb3B0aW9uPWdldEVudmlyb25tZW50T3B0aW9uKG9wdGlvbk5hbWUsJycpO1xucmV0dXJuIGZyZWV6ZShvcHRpb249PT0nJz9bXTpzdHJpbmdTcGxpdChvcHRpb24sJywnKSk7XG4gfTtcbmZyZWV6ZShnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTtcblxuY29uc3QgZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcz0ob3B0aW9uTmFtZSxlbGVtZW50KT0+XG5hcnJheUluY2x1ZGVzKGdldEVudmlyb25tZW50T3B0aW9uc0xpc3Qob3B0aW9uTmFtZSksZWxlbWVudCk7XG5cbmNvbnN0IGdldENhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcz0oKT0+e1xucmV0dXJuIGZyZWV6ZShbLi4uY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzXSk7XG4gfTtcbmZyZWV6ZShnZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXMpO1xuXG5yZXR1cm4gZnJlZXplKHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMsXG5nZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXN9KTtcblxuIH07JGjNj19vbmNlLm1ha2VFbnZpcm9ubWVudENhcHRvcihtYWtlRW52aXJvbm1lbnRDYXB0b3IpO1xuZnJlZXplKG1ha2VFbnZpcm9ubWVudENhcHRvcik7XG5cbi8qKlxuICogRm9yIHRoZSBzaW1wbGUgY2FzZSwgd2hlcmUgdGhlIGdsb2JhbCBpbiBxdWVzdGlvbiBpcyBgZ2xvYmFsVGhpc2AgYW5kIG5vXG4gKiByZXBvcnRpbmcgb2Ygb3B0aW9uIG5hbWVzIGlzIGRlc2lyZWQuXG4gKi9cbmNvbnN0ICAgICAgIHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXN9PVxubWFrZUVudmlyb25tZW50Q2FwdG9yKGdsb2JhbFRoaXMsdHJ1ZSk7JGjNj19vbmNlLmdldEVudmlyb25tZW50T3B0aW9uKGdldEVudmlyb25tZW50T3B0aW9uKTskaM2PX29uY2UuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdChnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTskaM2PX29uY2UuZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyhlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbnZpcm9ubWVudENhcHRvciI6WyJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwiZ2V0RW52aXJvbm1lbnRPcHRpb24iOlsiZ2V0RW52aXJvbm1lbnRPcHRpb24iXSwiZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCI6WyJnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0Il0sImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiOlsiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADnjB5W6QwAAOkMAAAcAAAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiRmFpbCIsIlgiLCJhbm5vdGF0ZUVycm9yIiwiYXNzZXJ0IiwiYiIsImJhcmUiLCJtYWtlRXJyb3IiLCJub3RlIiwicSIsInF1b3RlIiwicmVkYWN0ZWQiLCJ0aHJvd1JlZGFjdGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogVGhpcyBtb2R1bGUgYXNzdW1lcyB0aGUgZXhpc3RlbmNlIG9mIGEgbm9uLXN0YW5kYXJkIGBhc3NlcnRgIGhvc3Qgb2JqZWN0LiovXG4vKiBTRVMgdmVyc2lvbiAwLjExLjAgaW50cm9kdWNlcyB0aGlzIGdsb2JhbCBvYmplY3QgYW5kIGVudGFuZ2xlcyBpdCovXG4vKiB3aXRoIHRoZSBgY29uc29sZWAgaG9zdCBvYmplY3QgaW4gc2NvcGUgd2hlbiBpdCBpbml0aWFsaXplcywqL1xuLyogYWxsb3dpbmcgZXJyb3JzLCBwYXJ0aWN1bGFybHkgYXNzZXJ0aW9uIGVycm9ycywgdG8gaGlkZSB0aGVpciBcImRldGFpbHNcIiovXG4vKiBmcm9tIGNhbGxlcnMgdGhhdCBtaWdodCBjYXRjaCB0aG9zZSBlcnJvcnMsIHRoZW4gcmV2ZWFsIHRoZW0gdG8gdGhlKi9cbi8qIHVuZGVybHlpbmcgY29uc29sZS4qL1xuLyogVG8gdGhlIGV4dGVudCB0aGF0IHRoaXMgYGNvbnNvbGVgIGlzIGNvbnNpZGVyZWQgYSByZXNvdXJjZSwqL1xuLyogdGhpcyBtb2R1bGUgbXVzdCBiZSBjb25zaWRlcmVkIGEgcmVzb3VyY2UgbW9kdWxlLiovXG5cbi8qIFRoZSBhc3NlcnRpb25zIHJlLWV4cG9ydGVkIGhlcmUgYXJlIGRlZmluZWQgaW4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL2Fzc2VydC5qcyovXG5cbmNvbnN0IGdsb2JhbEFzc2VydD1nbG9iYWxUaGlzLmFzc2VydDtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAZW5kby9lcnJvcnMsIG1pc3NpbmcgZ2xvYmFsVGhpcy5hc3NlcnQsIGltcG9ydCAnc2VzJyBiZWZvcmUgJ0BlbmRvL2Vycm9ycydgKTtcblxuIH1cblxuY29uc3QgbWlzc2luZz0vKiogQHR5cGUge2NvbnN0fSAqL1tcbid0eXBlb2YnLFxuJ2Vycm9yJyxcbidmYWlsJyxcbidlcXVhbCcsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyB0aGF0Ki9cbi8qIHByZWRhdGVzIGFkZGl0aW9uIG9mIHRoZSAnYmFyZScgbWV0aG9kLCBzbyB3ZSBtdXN0IHRvbGVyYXRlIGl0cyBhYnNlbmNlIGFuZCBmYWxsKi9cbi8qIGJhY2sgdG8gcXVvdGUgYmVoYXZpb3IgaW4gdGhhdCBlbnZpcm9ubWVudCAoc2VlIGJlbG93KS4qL1xuLyogJ2JhcmUnLCovXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBlbmRvL2Vycm9ycywgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCBtZXRob2RzICR7bWlzc2luZy5qb2luKFxuJywgJylcbiB9YCk7XG5cbiB9XG5cbi8qIFRoZSBnbG9iYWwgYXNzZXJ0IG1peGVkIGFzc2VydGlvbnMgYW5kIHV0aWxpdHkgZnVuY3Rpb25zLiovXG4vKiBUaGlzIG1vZHVsZSBzcGxpdHMgdGhlbSBhcGFydCovXG4vKiBhbmQgYWxzbyB1cGRhdGVzIHRoZSBuYW1lcyBvZiB0aGUgdXRpbGl0eSBmdW5jdGlvbnMuKi9cbmNvbnN0e1xuYmFyZSxcbmRldGFpbHM6cmVkYWN0ZWQsXG5lcnJvcjptYWtlRXJyb3IsXG5GYWlsOnRocm93UmVkYWN0ZWQsXG5tYWtlQXNzZXJ0Ol9vbWl0dGVkTWFrZUFzc2VydCxcbm5vdGUsXG5xdW90ZSxcbi4uLmFzc2VydGlvbnN9PVxuZ2xvYmFsQXNzZXJ0O1xuLyoqIEB0eXBlIHtJTVBPUlQoXCJzZXNcIikuQXNzZXJ0aW9uRnVuY3Rpb25zIH0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgbWlzc2luZyBwcm9wZXJ0aWVzIGFzc2lnbmVkIG5leHQqLyRozY9fb25jZS5yZWRhY3RlZChyZWRhY3RlZCk7JGjNj19vbmNlLm1ha2VFcnJvcihtYWtlRXJyb3IpOyRozY9fb25jZS50aHJvd1JlZGFjdGVkKHRocm93UmVkYWN0ZWQpOyRozY9fb25jZS5ub3RlKG5vdGUpOyRozY9fb25jZS5xdW90ZShxdW90ZSk7XG5jb25zdCBhc3NlcnQ9KHZhbHVlLG9wdERldGFpbHMsZXJyQ29udHJ1Y3RvcixvcHRpb25zKT0+XG5nbG9iYWxBc3NlcnQodmFsdWUsb3B0RGV0YWlscyxlcnJDb250cnVjdG9yLG9wdGlvbnMpOyRozY9fb25jZS5hc3NlcnQoYXNzZXJ0KTtcbk9iamVjdC5hc3NpZ24oYXNzZXJ0LGFzc2VydGlvbnMpO1xuXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyovXG4vKiB0aGF0IHByZWRhdGVzIHRoZSBhZGRpdGlvbiBvZiB0aGUgJ2JhcmUnIG1ldGhvZCwgc28gd2UgbXVzdCBmYWxsIGJhY2sgdG8qL1xuLyogcXVvdGUgYmVoYXZpb3IgZm9yIHRoYXQgZW52aXJvbm1lbnQuKi9cbmNvbnN0IGJhcmVPclF1b3RlPWJhcmV8fHF1b3RlO1xuXG4vKiBYWFggbW9kdWxlIGV4cG9ydHMgZmFpbCBpZiB0aGVzZSBhcmVuJ3QgaW4gc2NvcGUqL1xuLyoqIEBpbXBvcnQge0Fzc2VydE1ha2VFcnJvck9wdGlvbnMsIERldGFpbHMsIEdlbmVyaWNFcnJvckNvbnN0cnVjdG9yfSBmcm9tICdzZXMnICovJGjNj19vbmNlLmJhcmVPclF1b3RlKGJhcmVPclF1b3RlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlZGFjdGVkIjpbInJlZGFjdGVkIl0sIlgiOlsicmVkYWN0ZWQiXSwibWFrZUVycm9yIjpbIm1ha2VFcnJvciJdLCJ0aHJvd1JlZGFjdGVkIjpbInRocm93UmVkYWN0ZWQiXSwiRmFpbCI6WyJ0aHJvd1JlZGFjdGVkIl0sIm5vdGUiOlsibm90ZSJdLCJhbm5vdGF0ZUVycm9yIjpbIm5vdGUiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJhc3NlcnQiOlsiYXNzZXJ0Il0sImJhcmUiOlsiYmFyZU9yUXVvdGUiXSwiYiI6WyJiYXJlT3JRdW90ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL0UuanN7ImltcG9ydHMiOlsiLi90cmFjay10dXJucy5qcyIsIi4vbWVzc2FnZS1icmVha3BvaW50cy5qcyJdLCJleHBvcnRzIjpbImRlZmF1bHQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgdHJhY2tUdXJucyxtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXI7JGjNj19pbXBvcnRzKFtbXCIuL3RyYWNrLXR1cm5zLmpzXCIsIFtbXCJ0cmFja1R1cm5zXCIsIFskaM2PX2EgPT4gKHRyYWNrVHVybnMgPSAkaM2PX2EpXV1dXSxbXCIuL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW1tcIm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlclwiLCBbJGjNj19hID0+IChtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWwsZXJyb3I6bWFrZUVycm9yfT1hc3NlcnQ7XG5jb25zdHthc3NpZ24sZnJlZXplfT1PYmplY3Q7XG5cbi8qKlxuICogQGltcG9ydCB7IEhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3IgfSBmcm9tICcuL3R5cGVzLmpzJztcbiAqL1xuXG5jb25zdCBvblNlbmQ9bWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyKCdFTkRPX1NFTkRfQlJFQUtQT0lOVFMnKTtcblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qIEUgUHJveHkgaGFuZGxlcnMgcHJldGVuZCB0aGF0IGFueSBwcm9wZXJ0eSBleGlzdHMgb24gdGhlIHRhcmdldCBhbmQgcmV0dXJucyovXG4vKiBhIGZ1bmN0aW9uIGZvciB0aGVpciB2YWx1ZS4gV2hpbGUgdGhpcyBmdW5jdGlvbiBpcyBcImJvdW5kXCIgYnkgY29udGV4dCwgaXQgaXMqL1xuLyogbWVhbnQgdG8gYmUgY2FsbGVkIGFzIGEgbWV0aG9kLiBGb3IgdGhhdCByZWFzb24sIHRoZSByZXR1cm5lZCBmdW5jdGlvbiovXG4vKiBpbmNsdWRlcyBhIGNoZWNrIHRoYXQgdGhlIGB0aGlzYCBhcmd1bWVudCBjb3JyZXNwb25kcyB0byB0aGUgaW5pdGlhbCovXG4vKiByZWNlaXZlciB3aGVuIHRoZSBmdW5jdGlvbiB3YXMgcmV0cmlldmVkLiovXG4vKiBFIFByb3h5IGhhbmRsZXJzIGFsc28gZm9yd2FyZCBkaXJlY3QgY2FsbHMgdG8gdGhlIHRhcmdldCBpbiBjYXNlIHRoZSByZW1vdGUqL1xuLyogaXMgYSBmdW5jdGlvbiBpbnN0ZWFkIG9mIGFuIG9iamVjdC4gTm8gc3VjaCByZWNlaXZlciBjaGVja3MgYXJlIG5lY2Vzc2FyeSBpbiovXG4vKiB0aGF0IGNhc2UuKi9cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHthbnl9IHJlY2lwaWVudCBBbnkgdmFsdWUgcGFzc2VkIHRvIEUoeClcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXI8dW5rbm93bj59IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFUHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IFByb21pc2U8dW5rbm93bj59ICovXG5bcHJvcGVydHlLZXldKC4uLmFyZ3Mpe1xuaWYodGhpcyE9PXJlY2VpdmVyKXtcbi8qIFJlamVjdCB0aGUgYXN5bmMgZnVuY3Rpb24gY2FsbCovXG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVqZWN0KFxubWFrZUVycm9yKFxuWCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3EocHJvcGVydHlLZXkpfVwiIG1ldGhvZCBvZiBFKCR7cShcbnJlY2lwaWVudClcbiB9KWApKTtcblxuXG4gfVxuXG5pZihvblNlbmQmJm9uU2VuZC5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxwcm9wZXJ0eUtleSkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBtZXRob2QtY2FsbCovXG4vKiBtZXNzYWdlLCovXG4vKiBzbyB0aGF0IHlvdSBjYW4gd2FsayBiYWNrIG9uIHRoZSBzdGFjayB0byBzZWUgaG93IHdlIGNhbWUgdG8qL1xuLyogbWFrZSB0aGlzIGV2ZW50dWFsLXNlbmQqL1xuIH1cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZChyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucHJvcGVydHlLZXldKTtcblxuIH0sXG5hcHBseTooX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSk9PntcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBmdW5jdGlvbi1jYWxsIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ0FycmF5KTtcbiB9LFxuaGFzOihfdGFyZ2V0LF9wKT0+e1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUuc2VuZE9ubHkoeClcbiAqIEl0IGlzIGEgdmFyaWFudCBvbiB0aGUgRSh4KSBQcm94eSBoYW5kbGVyLlxuICpcbiAqIEBwYXJhbSB7YW55fSByZWNpcGllbnQgQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge0hhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7UHJveHlIYW5kbGVyPHVua25vd24+fSB0aGUgUHJveHkgaGFuZGxlclxuICovXG5jb25zdCBtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IHVuZGVmaW5lZH0gKi9cbltwcm9wZXJ0eUtleV0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShcbnByb3BlcnR5S2V5KVxuIH1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EocmVjaXBpZW50KX0pYDtcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHByb3BlcnR5S2V5KSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIG1ldGhvZC1jYWxsKi9cbi8qIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxuSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2RTZW5kT25seShyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDMxOSovfVtcbnByb3BlcnR5S2V5XSk7XG5cbiB9LFxuYXBwbHk6KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKT0+e1xuaWYob25TZW5kJiZvblNlbmQuc2hvdWxkQnJlYWtwb2ludChyZWNpcGllbnQsdW5kZWZpbmVkKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIGZ1bmN0aW9uLWNhbGwgbWVzc2FnZSwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHdhbGsgYmFjayBvbiB0aGUgc3RhY2sgdG8gc2VlIGhvdyB3ZSBjYW1lIHRvKi9cbi8qIG1ha2UgdGhpcyBldmVudHVhbC1zZW5kKi9cbiB9XG5IYW5kbGVkUHJvbWlzZS5hcHBseUZ1bmN0aW9uU2VuZE9ubHkocmVjaXBpZW50LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXM6KF90YXJnZXQsX3ApPT57XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLmdldCh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHthbnl9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLmdldCh4KVxuICogQHBhcmFtIHtIYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcjx1bmtub3duPn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuY29uc3QgbWFrZUVHZXRQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzOihfdGFyZ2V0LF9wcm9wKT0+dHJ1ZSxcbmdldDooX3RhcmdldCxwcm9wKT0+SGFuZGxlZFByb21pc2UuZ2V0KHgscHJvcCl9KTtcblxuXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBmdW5jVGFyZ2V0PWZyZWV6ZSgoKT0+eyB9KTtcblxuLyoqXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBvYmpUYXJnZXQ9ZnJlZXplKHtfX3Byb3RvX186bnVsbH0pO1xuXG4vKipcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqL1xuY29uc3QgbWFrZUU9KEhhbmRsZWRQcm9taXNlKT0+e1xucmV0dXJuIGhhcmRlbihcbmFzc2lnbihcbi8qKlxuICogRSh4KSByZXR1cm5zIGEgcHJveHkgb24gd2hpY2ggeW91IGNhbiBjYWxsIGFyYml0cmFyeSBtZXRob2RzLiBFYWNoIG9mIHRoZXNlXG4gKiBtZXRob2QgY2FsbHMgcmV0dXJucyBhIHByb21pc2UuIFRoZSBtZXRob2Qgd2lsbCBiZSBpbnZva2VkIG9uIHdoYXRldmVyXG4gKiAneCcgZGVzaWduYXRlcyAob3IgcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgbWV0aG9kL2Z1bmN0aW9uIGNhbGxcbiAqIEByZXR1cm5zIHtFQ2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqL1xuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG4oeCk9Pm5ldyBQcm94eShmdW5jVGFyZ2V0LG1ha2VFUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcbntcbi8qKlxuICogRS5nZXQoeCkgcmV0dXJucyBhIHByb3h5IG9uIHdoaWNoIHlvdSBjYW4gZ2V0IGFyYml0cmFyeSBwcm9wZXJ0aWVzLlxuICogRWFjaCBvZiB0aGVzZSBwcm9wZXJ0aWVzIHJldHVybnMgYSBwcm9taXNlIGZvciB0aGUgcHJvcGVydHkuICBUaGUgcHJvbWlzZVxuICogdmFsdWUgd2lsbCBiZSB0aGUgcHJvcGVydHkgZmV0Y2hlZCBmcm9tIHdoYXRldmVyICd4JyBkZXNpZ25hdGVzIChvclxuICogcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgcHJvcGVydHkgZ2V0XG4gKiBAcmV0dXJucyB7RUdldHRlcnM8TG9jYWxSZWNvcmQ8VD4+fSBwcm9wZXJ0eSBnZXQgcHJveHlcbiAqIEByZWFkb25seVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCB0eXBlZGVmKi9cbmdldDooeCk9Pm5ldyBQcm94eShvYmpUYXJnZXQsbWFrZUVHZXRQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSkpLFxuXG4vKipcbiAqIEUucmVzb2x2ZSh4KSBjb252ZXJ0cyB4IHRvIGEgaGFuZGxlZCBwcm9taXNlLiBJdCBpc1xuICogc2hvcnRoYW5kIGZvciBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gaGFuZGxlZCBwcm9taXNlIGZvciB4XG4gKiBAcmVhZG9ubHlcbiAqL1xucmVzb2x2ZTpIYW5kbGVkUHJvbWlzZS5yZXNvbHZlLFxuXG4vKipcbiAqIEUuc2VuZE9ubHkgcmV0dXJucyBhIHByb3h5IHNpbWlsYXIgdG8gRSwgYnV0IGZvciB3aGljaCB0aGUgcmVzdWx0c1xuICogYXJlIGlnbm9yZWQgKHVuZGVmaW5lZCBpcyByZXR1cm5lZCkuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB0YXJnZXQgZm9yIG1ldGhvZC9mdW5jdGlvbiBjYWxsXG4gKiBAcmV0dXJucyB7RVNlbmRPbmx5Q2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqIEByZWFkb25seVxuICovXG5zZW5kT25seTooeCk9PlxuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG5uZXcgUHJveHkoZnVuY1RhcmdldCxtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcblxuLyoqXG4gKiBFLndoZW4oeCwgcmVzLCByZWopIGlzIGVxdWl2YWxlbnQgdG9cbiAqIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihyZXMsIHJlailcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtVID0gVF1cbiAqIEBwYXJhbSB7VHxQcm9taXNlTGlrZTxUPn0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gRVJlZjxVPn0gW29uZnVsZmlsbGVkXVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IEVSZWY8VT59IFtvbnJlamVjdGVkXVxuICogQHJldHVybnMge1Byb21pc2U8VT59XG4gKiBAcmVhZG9ubHlcbiAqL1xud2hlbjooeCxvbmZ1bGZpbGxlZCxvbnJlamVjdGVkKT0+XG5IYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4oXG4uLi50cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSkpfSkpO1xuXG5cblxuXG4gfTtcblxuY29uc3R7ZGVmYXVsdDokY82PX2RlZmF1bHR9PXtkZWZhdWx0Om1ha2VFfTtcblxuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPG1ha2VFPn0gRVByb3h5ICovXG5cbi8qKlxuICogRGVjbGFyZSBhbiBvYmplY3QgdGhhdCBpcyBwb3RlbnRpYWxseSBhIGZhciByZWZlcmVuY2Ugb2YgdHlwZSBQcmltYXJ5IHdob3NlXG4gKiBhdXhpbGxpYXJ5IGRhdGEgaGFzIHR5cGUgTG9jYWwuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yIGNvbnN1bWVycyBvZlxuICogRmFyIG9iamVjdHMgaW4gYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHRoZSBvbmx5IGNyZWF0b3JzIG9mIEZhciBvYmplY3RzXG4gKiBhcmUgZGlzdHJpYnV0ZWQgb2JqZWN0IGNyZWF0b3IgY29tcG9uZW50cyBsaWtlIHRoZSBgRmFyYCBvciBgUmVtb3RhYmxlYFxuICogZnVuY3Rpb25zLlxuICpcbiAqIEB0ZW1wbGF0ZSBQcmltYXJ5IFRoZSB0eXBlIG9mIHRoZSBwcmltYXJ5IHJlZmVyZW5jZS5cbiAqIEB0ZW1wbGF0ZSBbTG9jYWw9RGF0YU9ubHk8UHJpbWFyeT5dIFRoZSBsb2NhbCBwcm9wZXJ0aWVzIG9mIHRoZSBvYmplY3QuXG4gKiBAdHlwZWRlZiB7RVJlZjxMb2NhbCAmIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPExvY2FsLCBQcmltYXJ5Pj59IEZhclJlZlxuICovXG5cbi8qKlxuICogYERhdGFPbmx5PFQ+YCBtZWFucyB0byByZXR1cm4gYSByZWNvcmQgdHlwZSBgVDJgIGNvbnNpc3Rpbmcgb25seSBvZlxuICogcHJvcGVydGllcyB0aGF0IGFyZSAqbm90KiBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgdG8gYmUgZmlsdGVyZWQuXG4gKiBAdHlwZWRlZiB7T21pdDxULCBGaWx0ZXJlZEtleXM8VCwgSU1QT1JUKCcuL3R5cGVzLmpzJykuQ2FsbGFibGU+Pn0gRGF0YU9ubHlcbiAqL1xuXG4vKipcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMzEzOTR9XG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1Byb21pc2VMaWtlPFQ+IHwgVH0gRVJlZlxuICogRGVjbGFyZSB0aGF0IGBUYCBtYXkgb3IgbWF5IG5vdCBiZSBhIFByb21pc2UuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yXG4gKiBjb25zdW1lcnMgb2YgYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHJldHVybiB2YWx1ZXMgc2hvdWxkIHNwZWNpZmljYWxseSBiZVxuICogYFByb21pc2U8VD5gIG9yIGBUYCBpdHNlbGYuXG4gKi9cblxuLyoqXG4gKiBUaGUgYXdhaXRlZCByZXR1cm4gdHlwZSBvZiBhIGZ1bmN0aW9uLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgKC4uLmFyZ3M6IGFueVtdKSA9PiBpbmZlciBSID8gQXdhaXRlZDxSPiA6IG5ldmVyfSBFUmV0dXJuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBSZXR1cm5UeXBlPFQ+IGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT4gICAgICAgICAgICAgICAgICAgICAgIC8vIGlmIGZ1bmN0aW9uIHJldHVybnMgYSBwcm9taXNlXG4gKiAgICAgPyBUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIHRoZSBmdW5jdGlvblxuICogICAgIDogKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8RVJldHVybjxUPj4gIC8vIG1ha2UgaXQgcmV0dXJuIGEgcHJvbWlzZVxuICogKX0gRUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRUNhbGxhYmxlPFRbUF0+XG4gKiAgICAgOiBuZXZlcjtcbiAqIH19IEVNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPlxuICogICAgID8gVFtQXVxuICogICAgIDogUHJvbWlzZTxBd2FpdGVkPFRbUF0+PjtcbiAqIH19IEVHZXR0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8dm9pZD59IEVTZW5kT25seUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VFtQXT5cbiAqICAgICA6IG5ldmVyO1xuICogfX0gRVNlbmRPbmx5TWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VD4gJiBFU2VuZE9ubHlNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogICAgIDogRVNlbmRPbmx5TWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICl9IEVTZW5kT25seUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyBFQ2FsbGFibGU8VD4gJiBFTWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICAgICA6IEVNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogKX0gRUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBSZXR1cm4gYSB1bmlvbiBvZiBwcm9wZXJ0eSBuYW1lcy9zeW1ib2xzL251bWJlcnMgUCBmb3Igd2hpY2ggdGhlIHJlY29yZCBlbGVtZW50IFRbUF0ncyB0eXBlIGV4dGVuZHMgVS5cbiAqXG4gKiBHaXZlbiBjb25zdCB4ID0geyBhOiAxMjMsIGI6ICdoZWxsbycsIGM6IDQyLCA0OTogKCkgPT4ge30sIDUzOiA2NyB9LFxuICpcbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgbnVtYmVyPiBpcyB0aGUgdHlwZSAnYScgfCAnYycgfCA1My5cbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgc3RyaW5nPiBpcyB0aGUgdHlwZSAnYicuXG4gKiBGaWx0ZXJlZEtleXM8dHlwZW9mIHgsIDQyIHwgNjc+IGlzIHRoZSB0eXBlICdjJyB8IDUzLlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBib29sZWFuPiBpcyB0aGUgdHlwZSBuZXZlci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFVcbiAqIEB0eXBlZGVmIHt7IFtQIGluIGtleW9mIFRdOiBUW1BdIGV4dGVuZHMgVSA/IFAgOiBuZXZlcjsgfVtrZXlvZiBUXX0gRmlsdGVyZWRLZXlzXG4gKi9cblxuLyoqXG4gKiBgUGlja0NhbGxhYmxlPFQ+YCBtZWFucyB0byByZXR1cm4gYSBzaW5nbGUgcm9vdCBjYWxsYWJsZSBvciBhIHJlY29yZCB0eXBlXG4gKiBjb25zaXN0aW5nIG9ubHkgb2YgcHJvcGVydGllcyB0aGF0IGFyZSBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFJldHVyblR5cGU8VD4gICAgICAgICAgICAgICAgICAgICAvLyBhIHJvb3QgY2FsbGFibGUsIG5vIG1ldGhvZHNcbiAqICAgICA6IFBpY2s8VCwgRmlsdGVyZWRLZXlzPFQsIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPj4gICAgICAgICAgLy8gYW55IGNhbGxhYmxlIG1ldGhvZHNcbiAqICl9IFBpY2tDYWxsYWJsZVxuICovXG5cbi8qKlxuICogYFJlbW90ZUZ1bmN0aW9uczxUPmAgbWVhbnMgdG8gcmV0dXJuIHRoZSBmdW5jdGlvbnMgYW5kIHByb3BlcnRpZXMgdGhhdCBhcmUgcmVtb3RlbHkgY2FsbGFibGUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPiAgICAgLy8gaWYgYSBnaXZlbiBUIGlzIHNvbWUgcmVtb3RlIGludGVyZmFjZSBSXG4gKiAgICAgPyBQaWNrQ2FsbGFibGU8Uj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gdGhlIGNhbGxhYmxlIHByb3BlcnRpZXMgb2YgUlxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+IC8vIG90aGVyd2lzZSwgaWYgdGhlIGZpbmFsIHJlc29sdXRpb24gb2YgVCBpcyBzb21lIHJlbW90ZSBpbnRlcmZhY2UgUlxuICogICAgID8gUGlja0NhbGxhYmxlPFI+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIHRoZW4gcmV0dXJuIHRoZSBjYWxsYWJsZSBwcm9wZXJ0aWVzIG9mIFJcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UsIGlmIFQgaXMgYSBwcm9taXNlXG4gKiAgICAgPyBBd2FpdGVkPFQ+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gcmVzb2x2ZWQgdmFsdWUgVFxuICogICAgIDogVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG90aGVyd2lzZSwgcmV0dXJuIFRcbiAqICl9IFJlbW90ZUZ1bmN0aW9uc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPlxuICogICAgID8gTFxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+XG4gKiAgICAgPyBMXG4gKiAgICAgOiBUIGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT5cbiAqICAgICA/IEF3YWl0ZWQ8VD5cbiAqICAgICA6IFRcbiAqICl9IExvY2FsUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1IgPSB1bmtub3duXVxuICogQHR5cGVkZWYge3tcbiAqICAgcHJvbWlzZTogUHJvbWlzZTxSPjtcbiAqICAgc2V0dGxlcjogSU1QT1JUKCcuL3R5cGVzLmpzJykuU2V0dGxlcjxSPjtcbiAqIH19IEVQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBEZWNsYXJlIGEgbmVhciBvYmplY3QgdGhhdCBtdXN0IG9ubHkgYmUgaW52b2tlZCB3aXRoIEUsIGV2ZW4gbG9jYWxseS4gIEl0XG4gKiBzdXBwb3J0cyB0aGUgYFRgIGludGVyZmFjZSBidXQgYWRkaXRpb25hbGx5IHBlcm1pdHMgYFRgJ3MgbWV0aG9kcyB0byByZXR1cm5cbiAqIGBQcm9taXNlTGlrZWBzIGV2ZW4gaWYgYFRgIGRlY2xhcmVzIHRoZW0gYXMgb25seSBzeW5jaHJvbm91cy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VD4+Pj5cbiAqICAgICA6IFQgZXh0ZW5kcyBSZWNvcmQ8UHJvcGVydHlLZXksIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPlxuICogICAgID8ge1xuICogICAgICAgICBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgICAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUW0tdPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VFtLXT4+Pj5cbiAqICAgICAgICAgICA6IFRbS107XG4gKiAgICAgICB9XG4gKiAgICAgOiBUXG4gKiApfSBFT25seVxuICovJGjNj19vbmNlLmRlZmF1bHQoJGPNj19kZWZhdWx0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2V4cG9ydHMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG2wnmyYEQAAmBEAACcAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanN7ImltcG9ydHMiOlsiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOlsiZ2V0TWV0aG9kTmFtZXMiLCJsb2NhbEFwcGx5RnVuY3Rpb24iLCJsb2NhbEFwcGx5TWV0aG9kIiwibG9jYWxHZXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyOyRozY9faW1wb3J0cyhbW1wiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzXCIsIFtbXCJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcIiwgWyRozY9fYSA9PiAobWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyID0gJGjNj19hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzLGdldFByb3RvdHlwZU9mLGZyZWV6ZX09T2JqZWN0O1xuY29uc3R7YXBwbHksb3duS2V5c309UmVmbGVjdDtcblxuY29uc3QgbnR5cGVvZj0oc3BlY2ltZW4pPT5zcGVjaW1lbj09PW51bGw/J251bGwnOnR5cGVvZiBzcGVjaW1lbjtcblxuY29uc3Qgb25EZWxpdmVyeT1tYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIoJ0VORE9fREVMSVZFUllfQlJFQUtQT0lOVFMnKTtcblxuLyoqXG4gKiBUT0RPIENvbnNvbGlkYXRlIHdpdGggYGlzT2JqZWN0YCB0aGF0J3MgY3VycmVudGx5IGluIGBAZW5kby9tYXJzaGFsYFxuICpcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7XG5cbi8qKlxuICogUHJpb3JpdGl6ZSBzeW1ib2xzIGFzIGVhcmxpZXIgdGhhbiBzdHJpbmdzLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0gYVxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBiXG4gKiBAcmV0dXJucyB7LTEgfCAwIHwgMX1cbiAqL1xuY29uc3QgY29tcGFyZVN0cmluZ2lmaWVkPShhLGIpPT57XG5pZih0eXBlb2YgYT09PXR5cGVvZiBiKXtcbmNvbnN0IGxlZnQ9U3RyaW5nKGEpO1xuY29uc3QgcmlnaHQ9U3RyaW5nKGIpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLW5lc3RlZC10ZXJuYXJ5Ki9cbnJldHVybiBsZWZ0PHJpZ2h0Py0xOmxlZnQ+cmlnaHQ/MTowO1xuIH1cbmlmKHR5cGVvZiBhPT09J3N5bWJvbCcpe1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N0cmluZycpO1xucmV0dXJuLTE7XG4gfVxuYXNzZXJ0KHR5cGVvZiBhPT09J3N0cmluZycpO1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N5bWJvbCcpO1xucmV0dXJuIDE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGRlc2NzKSl7XG4vKiBJbiBjYXNlIGEgbWV0aG9kIGlzIG92ZXJyaWRkZW4gYnkgYSBub24tbWV0aG9kLCovXG4vKiB0ZXN0IGB2YWxbbmFtZV1gIHJhdGhlciB0aGFuIGBsYXllcltuYW1lXWAqL1xuaWYodHlwZW9mIHZhbFtuYW1lXT09PSdmdW5jdGlvbicpe1xubmFtZXMuYWRkKG5hbWUpO1xuIH1cbiB9XG5pZighaXNPYmplY3QodmFsKSl7XG5icmVhaztcbiB9XG5sYXllcj1nZXRQcm90b3R5cGVPZihsYXllcik7XG4gfVxucmV0dXJuIGhhcmRlbihbLi4ubmFtZXNdLnNvcnQoY29tcGFyZVN0cmluZ2lmaWVkKSk7XG4gfTtcbi8qIFRoZSB0b3AgbGV2ZWwgb2YgdGhlIGV2ZW50dWFsIHNlbmQgbW9kdWxlcyBjYW4gYmUgZXZhbHVhdGVkIGJlZm9yZSovXG4vKiBzZXMgY3JlYXRlcyBgaGFyZGVuYCwgYW5kIHNvIGNhbm5vdCByZWx5IG9uIGBoYXJkZW5gIGF0IHRvcCBsZXZlbC4qLyRozY9fb25jZS5nZXRNZXRob2ROYW1lcyhnZXRNZXRob2ROYW1lcyk7XG5mcmVlemUoZ2V0TWV0aG9kTmFtZXMpO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseUZ1bmN0aW9uPShyZWNpcGllbnQsYXJncyk9PntcbnR5cGVvZiByZWNpcGllbnQ9PT0nZnVuY3Rpb24nfHxcbmFzc2VydC5mYWlsKFxuWCBgQ2Fubm90IGludm9rZSB0YXJnZXQgYXMgYSBmdW5jdGlvbjsgdHlwZW9mIHRhcmdldCBpcyAke3EoXG5udHlwZW9mKHJlY2lwaWVudCkpXG4gfWAsXG5UeXBlRXJyb3IpO1xuXG5pZihvbkRlbGl2ZXJ5JiZvbkRlbGl2ZXJ5LnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIFNURVAgSU5UTyBBUFBMWSovXG4vKiBTdG9wcGVkIGF0IGEgYnJlYWtwb2ludCBvbiB0aGlzIGRlbGl2ZXJ5IG9mIGFuIGV2ZW50dWFsIGZ1bmN0aW9uIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIGZ1bmN0aW9uIGNhbGwgYXMgaXQgaGFwcGVucy4gT3Igc3RlcCAqb3ZlciogdG8gc2VlIHdoYXQgaGFwcGVucyovXG4vKiBhZnRlciB0aGUgZnVuY3Rpb24gY2FsbCByZXR1cm5zLiovXG4gfVxuY29uc3QgcmVzdWx0PWFwcGx5KHJlY2lwaWVudCx1bmRlZmluZWQsYXJncyk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjNj19vbmNlLmxvY2FsQXBwbHlGdW5jdGlvbihsb2NhbEFwcGx5RnVuY3Rpb24pO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseU1ldGhvZD0ocmVjaXBpZW50LG1ldGhvZE5hbWUsYXJncyk9PntcbmlmKG1ldGhvZE5hbWU9PT11bmRlZmluZWR8fG1ldGhvZE5hbWU9PT1udWxsKXtcbi8qIEJhc2UgY2FzZTsgYm90dG9tIG91dCB0byBhcHBseSBmdW5jdGlvbnMuKi9cbnJldHVybiBsb2NhbEFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ3MpO1xuIH1cbmlmKHJlY2lwaWVudD09PXVuZGVmaW5lZHx8cmVjaXBpZW50PT09bnVsbCl7XG5hc3NlcnQuZmFpbChcblggYENhbm5vdCBkZWxpdmVyICR7cShtZXRob2ROYW1lKX0gdG8gdGFyZ2V0OyB0eXBlb2YgdGFyZ2V0IGlzICR7cShcbm50eXBlb2YocmVjaXBpZW50KSlcbiB9YCxcblR5cGVFcnJvcik7XG5cbiB9XG5jb25zdCBmbj1yZWNpcGllbnRbbWV0aG9kTmFtZV07XG5pZihmbj09PXVuZGVmaW5lZCl7XG5hc3NlcnQuZmFpbChcblggYHRhcmdldCBoYXMgbm8gbWV0aG9kICR7cShtZXRob2ROYW1lKX0sIGhhcyAke3EoXG5nZXRNZXRob2ROYW1lcyhyZWNpcGllbnQpKVxuIH1gLFxuVHlwZUVycm9yKTtcblxuIH1cbmNvbnN0IGZ0eXBlPW50eXBlb2YoZm4pO1xudHlwZW9mIGZuPT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBpbnZva2VkIG1ldGhvZCAke3EobWV0aG9kTmFtZSl9IGlzIG5vdCBhIGZ1bmN0aW9uOyBpdCBpcyBhICR7cShcbmZ0eXBlKVxuIH1gO1xuaWYob25EZWxpdmVyeSYmb25EZWxpdmVyeS5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxtZXRob2ROYW1lKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogU1RFUCBJTlRPIEFQUExZKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIHRoaXMgZGVsaXZlcnkgb2YgYW4gZXZlbnR1YWwgbWV0aG9kIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIG1ldGhvZCBjYWxsIGFzIGl0IGhhcHBlbnMuIE9yIHN0ZXAgKm92ZXIqIHRvIHNlZSB3aGF0IGhhcHBlbnMqL1xuLyogYWZ0ZXIgdGhlIG1ldGhvZCBjYWxsIHJldHVybnMuKi9cbiB9XG5jb25zdCByZXN1bHQ9YXBwbHkoZm4scmVjaXBpZW50LGFyZ3MpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRozY9fb25jZS5sb2NhbEFwcGx5TWV0aG9kKGxvY2FsQXBwbHlNZXRob2QpO1xuXG5jb25zdCAgICAgICAgbG9jYWxHZXQ9KHQsa2V5KT0+dFtrZXldOyRozY9fb25jZS5sb2NhbEdldChsb2NhbEdldCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJsb2NhbEFwcGx5RnVuY3Rpb24iOlsibG9jYWxBcHBseUZ1bmN0aW9uIl0sImxvY2FsQXBwbHlNZXRob2QiOlsibG9jYWxBcHBseU1ldGhvZCJdLCJsb2NhbEdldCI6WyJsb2NhbEdldCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABt8TAWoRYAAKEWAAA1AAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgZ2V0RW52aXJvbm1lbnRPcHRpb247JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuY29uc3R7aGFzT3duLGZyZWV6ZSxlbnRyaWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZyB8ICcqJ30gTWF0Y2hTdHJpbmdUYWdcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IHJlY2lwaWVudC4gT3RoZXJ3aXNlLCB0aGUgc3RyaW5nIGlzXG4gKiAgIG1hdGNoZWQgYWdhaW5zdCB0aGUgdmFsdWUgb2YgYSByZWNpcGllbnQncyBgQEB0b1N0cmluZ1RhZ2BcbiAqICAgYWZ0ZXIgc3RyaXBwaW5nIG91dCBhbnkgbGVhZGluZyBgJ0FsbGVnZWQ6ICdgIG9yIGAnRGVidWdOYW1lOiAnYFxuICogICBwcmVmaXguIEZvciBvYmplY3RzIGRlZmluZWQgd2l0aCBgRmFyYCB0aGlzIGlzIHRoZSBmaXJzdCBhcmd1bWVudCxcbiAqICAga25vd24gYXMgdGhlIGBmYXJOYW1lYC4gRm9yIGV4b3MsIHRoaXMgaXMgdGhlIHRhZy5cbiAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgJyonfSBNYXRjaE1ldGhvZE5hbWVcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IG1ldGhvZCBuYW1lLiBPdGhlcndpc2UsIHRoZSBzdHJpbmcgaXNcbiAqICAgbWF0Y2hlZCBhZ2FpbnN0IHRoZSBtZXRob2QgbmFtZS4gQ3VycmVudGx5LCB0aGlzIGlzIG9ubHkgYW4gZXhhY3QgbWF0Y2guXG4gKiAgIEhvd2V2ZXIsIGJld2FyZSB0aGF0IHdlIG1heSBpbnRyb2R1Y2UgYSBzdHJpbmcgc3ludGF4IGZvclxuICogICBzeW1ib2wgbWV0aG9kIG5hbWVzLlxuICovXG4vKipcbiAqIEB0eXBlZGVmIHtudW1iZXIgfCAnKid9IE1hdGNoQ291bnRkb3duXG4gKiAgIEEgc3RhciBgJyonYCB3aWxsIGFsd2F5cyBicmVha3BvaW50LiBPdGhlcndpc2UsIHRoZSBzdHJpbmdcbiAqICAgbXVzdCBiZSBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyLiBPbmNlIHRoYXQgaXMgemVybywgYWx3YXlzIGJyZWFrcG9pbnQuXG4gKiAgIE90aGVyd2lzZSBkZWNyZW1lbnQgYnkgb25lIGVhY2ggdGltZSBpdCBtYXRjaGVzIHVudGlsIGl0IHJlYWNoZXMgemVyby5cbiAqICAgSW4gb3RoZXIgd29yZHMsIHRoZSBjb3VudGRvd24gcmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mXG4gKiAgIGJyZWFrcG9pbnQgb2NjdXJyZW5jZXMgdG8gc2tpcCBiZWZvcmUgYWN0dWFsbHkgYnJlYWtwb2ludGluZy5cbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIGV4dGVybmFsIEpTT04gcmVwcmVzZW50YXRpb24sIGluIHdoaWNoXG4gKiAtIHRoZSBvdXRlciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBjbGFzcy1saWtlIHRhZyBvciAnKicsXG4gKiAtIHRoZSBpbm5lciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBtZXRob2QgbmFtZSBvciAnKicsXG4gKiAtIHRoZSB2YWx1ZSBpcyBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyIGNvdW50ZG93biBvciAnKicuXG4gKlxuICogQHR5cGVkZWYge1JlY29yZDxNYXRjaFN0cmluZ1RhZywgUmVjb3JkPE1hdGNoTWV0aG9kTmFtZSwgTWF0Y2hDb3VudGRvd24+Pn0gTWVzc2FnZUJyZWFrcG9pbnRzXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBpbnRlcm5hbCBKU09OIHJlcHJlc2VudGF0aW9uLCBpbiB3aGljaFxuICogLSB0aGUgb3V0ZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgbWV0aG9kIG5hbWUgb3IgJyonLFxuICogLSB0aGUgaW5uZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgY2xhc3MtbGlrZSB0YWcgb3IgJyonLFxuICogLSB0aGUgdmFsdWUgaXMgYSBub24tbmVnYXRpdmUgaW50ZWdlciBjb3VudGRvd24gb3IgJyonLlxuICpcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8TWF0Y2hNZXRob2ROYW1lLCBSZWNvcmQ8TWF0Y2hTdHJpbmdUYWcsIE1hdGNoQ291bnRkb3duPj59IEJyZWFrcG9pbnRUYWJsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gTWVzc2FnZUJyZWFrcG9pbnRzfSBnZXRCcmVha3BvaW50c1xuICogQHByb3BlcnR5IHsobmV3QnJlYWtwb2ludHM/OiBNZXNzYWdlQnJlYWtwb2ludHMpID0+IHZvaWR9IHNldEJyZWFrcG9pbnRzXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVjaXBpZW50OiBvYmplY3QsXG4gKiAgIG1ldGhvZE5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IHVuZGVmaW5lZFxuICogKSA9PiBib29sZWFufSBzaG91bGRCcmVha3BvaW50XG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7dmFsIGlzIFJlY29yZDxzdHJpbmcsIGFueT59XG4gKi9cbmNvbnN0IGlzSlNPTlJlY29yZD0odmFsKT0+XG50eXBlb2YgdmFsPT09J29iamVjdCcmJnZhbCE9PW51bGwmJiFBcnJheS5pc0FycmF5KHZhbCk7XG5cbi8qKlxuICogUmV0dXJuIGB0YWdgIGFmdGVyIHN0cmlwcGluZyBvZmYgYW55IGAnQWxsZWdlZDogJ2Agb3IgYCdEZWJ1Z05hbWU6ICdgXG4gKiBwcmVmaXggaWYgcHJlc2VudC5cbiAqIGBgYGpzXG4gKiBzaW1wbGlmeVRhZygnQWxsZWdlZDogbW9vbGEgaXNzdWVyJykgPT09ICdtb29sYSBpc3N1ZXInXG4gKiBgYGBcbiAqIElmIHRoZXJlIGFyZSBtdWx0aXBsZSBzdWNoIHByZWZpeGVzLCBvbmx5IHRoZSBvdXRlciBvbmUgaXMgcmVtb3ZlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBzaW1wbGlmeVRhZz0odGFnKT0+e1xuZm9yKGNvbnN0IHByZWZpeCBvZlsnQWxsZWdlZDogJywnRGVidWdOYW1lOiAnXSl7XG5pZih0YWcuc3RhcnRzV2l0aChwcmVmaXgpKXtcbnJldHVybiB0YWcuc2xpY2UocHJlZml4Lmxlbmd0aCk7XG4gfVxuIH1cbnJldHVybiB0YWc7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge01lc3NhZ2VCcmVha3BvaW50VGVzdGVyIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCAgICAgICAgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyPShvcHRpb25OYW1lKT0+e1xubGV0IGJyZWFrcG9pbnRzPUpTT04ucGFyc2UoZ2V0RW52aXJvbm1lbnRPcHRpb24ob3B0aW9uTmFtZSwnbnVsbCcpKTtcblxuaWYoYnJlYWtwb2ludHM9PT1udWxsKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbmxldCBicmVha3BvaW50c1RhYmxlO1xuXG5jb25zdCBnZXRCcmVha3BvaW50cz0oKT0+YnJlYWtwb2ludHM7XG5mcmVlemUoZ2V0QnJlYWtwb2ludHMpO1xuXG5jb25zdCBzZXRCcmVha3BvaW50cz0obmV3QnJlYWtwb2ludHM9YnJlYWtwb2ludHMpPT57XG5pc0pTT05SZWNvcmQobmV3QnJlYWtwb2ludHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uIHRvIGJlIGEgSlNPTiBicmVha3BvaW50cyByZWNvcmRgO1xuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbmNvbnN0IG5ld0JyZWFrcG9pbnRzVGFibGU9e19fcHJvdG9fXzpudWxsfTtcblxuZm9yKGNvbnN0W3RhZyxtZXRob2RCUHNdb2YgZW50cmllcyhuZXdCcmVha3BvaW50cykpe1xudGFnPT09c2ltcGxpZnlUYWcodGFnKXx8XG5GYWlsIGBKdXN0IHVzZSBzaW1wbGUgdGFnICR7cShzaW1wbGlmeVRhZyh0YWcpKX0gcmF0aGVyIHRoYW4gJHtxKHRhZyl9YDtcbmlzSlNPTlJlY29yZChtZXRob2RCUHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uJ3MgJHtxKFxudGFnKVxuIH0gdG8gYmUgYSBKU09OIG1ldGhvZHMgYnJlYWtwb2ludHMgcmVjb3JkYDtcbmZvcihjb25zdFttZXRob2ROYW1lLGNvdW50XW9mIGVudHJpZXMobWV0aG9kQlBzKSl7XG5jb3VudD09PScqJ3x8XG50eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmXG5OdW1iZXIuaXNTYWZlSW50ZWdlcihjb3VudCkmJlxuY291bnQ+PTB8fFxuRmFpbCBgRXhwZWN0ZWQgJHtxKG9wdGlvbk5hbWUpfSBvcHRpb24ncyAke3EodGFnKX0uJHtxKFxubWV0aG9kTmFtZSlcbiB9IHRvIGJlIFwiKlwiIG9yIGEgbm9uLW5lZ2F0aXZlIGludGVnZXJgO1xuXG5jb25zdCBjbGFzc0JQcz1oYXNPd24obmV3QnJlYWtwb2ludHNUYWJsZSxtZXRob2ROYW1lKT9cbm5ld0JyZWFrcG9pbnRzVGFibGVbbWV0aG9kTmFtZV06XG5uZXdCcmVha3BvaW50c1RhYmxlW21ldGhvZE5hbWVdPXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbl9fcHJvdG9fXzpudWxsfTtcblxuY2xhc3NCUHNbdGFnXT1jb3VudDtcbiB9XG4gfVxuYnJlYWtwb2ludHM9bmV3QnJlYWtwb2ludHM7XG5icmVha3BvaW50c1RhYmxlPW5ld0JyZWFrcG9pbnRzVGFibGU7XG4gfTtcbmZyZWV6ZShzZXRCcmVha3BvaW50cyk7XG5cbmNvbnN0IHNob3VsZEJyZWFrcG9pbnQ9KHJlY2lwaWVudCxtZXRob2ROYW1lKT0+e1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZHx8bWV0aG9kTmFtZT09PW51bGwpe1xuLyogVE9ETyBlbmFibGUgZnVuY3Rpb24gYnJlYWtwb2ludGluZyovXG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgY2xhc3NCUHM9YnJlYWtwb2ludHNUYWJsZVttZXRob2ROYW1lXXx8YnJlYWtwb2ludHNUYWJsZVsnKiddO1xuaWYoY2xhc3NCUHM9PT11bmRlZmluZWQpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmxldCB0YWc9c2ltcGxpZnlUYWcocmVjaXBpZW50W1N5bWJvbC50b1N0cmluZ1RhZ10pO1xubGV0IGNvdW50PWNsYXNzQlBzW3RhZ107XG5pZihjb3VudD09PXVuZGVmaW5lZCl7XG50YWc9JyonO1xuY291bnQ9Y2xhc3NCUHNbdGFnXTtcbmlmKGNvdW50PT09dW5kZWZpbmVkKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuaWYoY291bnQ9PT0nKicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoY291bnQ9PT0wKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydCh0eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmY291bnQ+PTEpO1xuY2xhc3NCUHNbdGFnXT1jb3VudC0xO1xucmV0dXJuIGZhbHNlO1xuIH07XG5mcmVlemUoc2hvdWxkQnJlYWtwb2ludCk7XG5cbmNvbnN0IGJyZWFrcG9pbnRUZXN0ZXI9ZnJlZXplKHtcbmdldEJyZWFrcG9pbnRzLFxuc2V0QnJlYWtwb2ludHMsXG5zaG91bGRCcmVha3BvaW50fSk7XG5cbmJyZWFrcG9pbnRUZXN0ZXIuc2V0QnJlYWtwb2ludHMoKTtcbnJldHVybiBicmVha3BvaW50VGVzdGVyO1xuIH07JGjNj19vbmNlLm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlcihtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIpO1xuZnJlZXplKG1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3Rlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiOlsibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABeEUwx5AwAAeQMAACkAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbm8tc2hpbS5qc3siaW1wb3J0cyI6WyIuL0UuanMiLCIuL2V4cG9ydHMuanMiXSwiZXhwb3J0cyI6WyJFIiwiSGFuZGxlZFByb21pc2UiXSwicmVleHBvcnRzIjpbIi4vZXhwb3J0cy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBtYWtlRTskaM2PX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbW1wiZGVmYXVsdFwiLCBbJGjNj19hID0+IChtYWtlRSA9ICRozY9fYSldXV1dLFtcIi4vZXhwb3J0cy5qc1wiLCBbXV1dKTsgICBcblxuLyogWFhYIG1vZHVsZSBleHBvcnRzIGZvciBIYW5kbGVkUHJvbWlzZSBmYWlsIGlmIHRoZXNlIGFyZW4ndCBpbiBzY29wZSovXG4vKiogQGltcG9ydCB7SGFuZGxlciwgSGFuZGxlZEV4ZWN1dG9yfSBmcm9tICcuL2hhbmRsZWQtcHJvbWlzZS5qcycgKi9cbi8qKiBAaW1wb3J0IHtFQ2FsbGFibGVPck1ldGhvZHMsIEVHZXR0ZXJzLCBFUmVmLCBFUmVtb3RlRnVuY3Rpb25zLCBFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kcywgTG9jYWxSZWNvcmQsIFJlbW90ZUZ1bmN0aW9uc30gZnJvbSAnLi9FLmpzJyAqL1xuXG5jb25zdCBocD1IYW5kbGVkUHJvbWlzZTskaM2PX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoaHApOyRozY9fb25jZS5FKEUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiSGFuZGxlZFByb21pc2UiOlsiaHAiXSwiRSI6WyJFIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB6458vtEAAA7RAAAC0AAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJ0cmFja1R1cm5zIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLGVudmlyb25tZW50T3B0aW9uc0xpc3RIYXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV0sW1wiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhc1wiLCBbJGjNj19hID0+IChlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIFdlIGFsc28gY2Fubm90IGN1cnJlbnRseSBpbXBvcnQgdGhlbSBiZWNhdXNlIGl0IHdvdWxkIGNyZWF0ZSBhIGN5Y2xpYyovXG4vKiBkZXBlbmRlbmN5LCB0aG91Z2ggdGhpcyBpcyBtb3JlIGVhc2lseSBmaXhlZC4qL1xuLyogaW1wb3J0IHsgYXNzZXJ0LCBYLCBGYWlsIH0gZnJvbSAnQGVuZG8vZXJyb3JzJzsqL1xuLyogU2VlIGFsc28gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85NTE1Ki9cblxuLyogV0FSTklORzogR2xvYmFsIE11dGFibGUgU3RhdGUhKi9cbi8qIFRoaXMgc3RhdGUgaXMgY29tbXVuaWNhdGVkIHRvIGBhc3NlcnRgIHRoYXQgbWFrZXMgaXQgYXZhaWxhYmxlIHRvIHRoZSovXG4vKiBjYXVzYWwgY29uc29sZSwgd2hpY2ggYWZmZWN0cyB0aGUgY29uc29sZSBsb2cgb3V0cHV0LiBOb3JtYWxseSB3ZSovXG4vKiByZWdhcmQgdGhlIGFiaWxpdHkgdG8gc2VlIGNvbnNvbGUgbG9nIG91dHB1dCBhcyBhIG1ldGEtbGV2ZWwgcHJpdmlsZWdlKi9cbi8qIGFuYWxvZ291cyB0byB0aGUgYWJpbGl0eSB0byBkZWJ1Zy4gQXNpZGUgZnJvbSB0aGF0LCB0aGlzIG1vZHVsZSBzaG91bGQqL1xuLyogbm90IGhhdmUgYW55IG9ic2VydmFibHkgbXV0YWJsZSBzdGF0ZS4qL1xuXG5sZXQgaGlkZGVuUHJpb3JFcnJvcjtcbmxldCBoaWRkZW5DdXJyZW50VHVybj0wO1xubGV0IGhpZGRlbkN1cnJlbnRFdmVudD0wO1xuXG4vKiBUdXJuIG9uIGlmIHlvdSBzZWVtIHRvIGJlIGxvc2luZyBlcnJvciBsb2dnaW5nIGF0IHRoZSB0b3Agb2YgdGhlIGV2ZW50IGxvb3AqL1xuY29uc3QgVkVSQk9TRT1lbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKCdERUJVRycsJ3RyYWNrLXR1cm5zJyk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBlbmFibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgRU5BQkxFRD1cbmdldEVudmlyb25tZW50T3B0aW9uKCdUUkFDS19UVVJOUycsJ2Rpc2FibGVkJyxbJ2VuYWJsZWQnXSk9PT0nZW5hYmxlZCc7XG5cbi8qIFdlIGhvaXN0IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIG91dCBvZiB0cmFja1R1cm5zKCkgdG8gZGlzY291cmFnZSB0aGUqL1xuLyogY2xvc3VyZXMgZnJvbSBob2xkaW5nIG9udG8gJ2FyZ3MnIG9yICdmdW5jJyBsb25nZXIgdGhhbiBuZWNlc3NhcnksKi9cbi8qIHdoaWNoIHdlJ3ZlIHNlZW4gY2F1c2UgSGFuZGxlZFByb21pc2UgYXJndW1lbnRzIHRvIGJlIHJldGFpbmVkIGZvciovXG4vKiBhIHN1cnByaXNpbmdseSBsb25nIHRpbWUuKi9cblxuY29uc3QgYWRkUmVqZWN0aW9uTm90ZT0oZGV0YWlsc05vdGUpPT4ocmVhc29uKT0+e1xuaWYocmVhc29uIGluc3RhbmNlb2YgRXJyb3Ipe1xuZ2xvYmFsVGhpcy5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9O1xuXG5jb25zdCB3cmFwRnVuY3Rpb249XG4oZnVuYyxzZW5kaW5nRXJyb3IsWCk9PlxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5nbG9iYWxUaGlzLmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goYWRkUmVqZWN0aW9uTm90ZShkZXRhaWxzTm90ZSkpO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9O1xuXG4vKipcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAdGVtcGxhdGUge1R1cm5TdGFydGVyRm5bXX0gVFxuICogQHBhcmFtIHtUfSBmdW5jc1xuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICB0cmFja1R1cm5zPShmdW5jcyk9PntcbmlmKCFFTkFCTEVEfHx0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WCxub3RlOmFubm90YXRlRXJyb3J9PWdsb2JhbFRoaXMuYXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9RXJyb3IoXG4gYEV2ZW50OiAke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuaWYoaGlkZGVuUHJpb3JFcnJvciE9PXVuZGVmaW5lZCl7XG5hbm5vdGF0ZUVycm9yKHNlbmRpbmdFcnJvcixYIGBDYXVzZWQgYnk6ICR7aGlkZGVuUHJpb3JFcnJvcn1gKTtcbiB9XG5cbnJldHVybiAoLyoqIEB0eXBlIHtUfSAqL1xuZnVuY3MubWFwKChmdW5jKT0+ZnVuYyYmd3JhcEZ1bmN0aW9uKGZ1bmMsc2VuZGluZ0Vycm9yLFgpKSk7XG5cbiB9O1xuXG4vKipcbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICpcbiAqIEB0eXBlZGVmIHsoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgdW5kZWZpbmVkfSBUdXJuU3RhcnRlckZuXG4gKi8kaM2PX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InRyYWNrVHVybnMiOlsidHJhY2tUdXJucyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA/8Oc6VgIAAFYCAAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvdXRpbHMuanN7ImltcG9ydHMiOlsiLi9zcmMvbG9jYWwuanMiLCIuL3NyYy9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOltudWxsLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvbG9jYWwuanNcIiwgW11dLFtcIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9sb2NhbC5qcyI6W1siZ2V0TWV0aG9kTmFtZXMiLCJnZXRNZXRob2ROYW1lcyJdXSwiLi9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyI6W1sibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIiwibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC4gWnwdAcAAHQHAAAdAAAAQGVuZG8vbWFyc2hhbC12MS42LjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9zcmMvbWFyc2hhbC5qcyIsIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIiwiLi9zcmMvbWFyc2hhbC1qdXN0aW4uanMiLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyIsIi4vc3JjL3JhbmtPcmRlci5qcyIsIi4vc3JjL3R5cGVzLmpzIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImFzc2VydFJhbmtTb3J0ZWQiLCJhc3NlcnRSYW5rU29ydGVkIiwibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIiwicGFyc2UiLCJwYXJzZSIsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW1tcIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtanVzdGluLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvcmFua09yZGVyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbXV1dKTsgICBcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyI6W1siUUNMQVNTIiwiUUNMQVNTIl1dLCIuL3NyYy9tYXJzaGFsLmpzIjpbWyJtYWtlTWFyc2hhbCIsIm1ha2VNYXJzaGFsIl1dLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6W1sic3RyaW5naWZ5Iiwic3RyaW5naWZ5Il0sWyJwYXJzZSIsInBhcnNlIl1dLCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6W1siZGVjb2RlVG9KdXN0aW4iLCJkZWNvZGVUb0p1c3RpbiJdXSwiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOltbIm1ha2VQYXNzYWJsZUtpdCIsIm1ha2VQYXNzYWJsZUtpdCJdLFsibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIl0sWyJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiXSxbImlzRW5jb2RlZFJlbW90YWJsZSIsImlzRW5jb2RlZFJlbW90YWJsZSJdLFsiemVyb1BhZCIsInplcm9QYWQiXSxbInJlY29yZE5hbWVzIiwicmVjb3JkTmFtZXMiXSxbInJlY29yZFZhbHVlcyIsInJlY29yZFZhbHVlcyJdXSwiLi9zcmMvcmFua09yZGVyLmpzIjpbWyJ0cml2aWFsQ29tcGFyYXRvciIsInRyaXZpYWxDb21wYXJhdG9yIl0sWyJhc3NlcnRSYW5rU29ydGVkIiwiYXNzZXJ0UmFua1NvcnRlZCJdLFsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayJdLFsiaXNSYW5rU29ydGVkIiwiaXNSYW5rU29ydGVkIl0sWyJzb3J0QnlSYW5rIiwic29ydEJ5UmFuayJdLFsiY29tcGFyZUFudGlSYW5rIiwiY29tcGFyZUFudGlSYW5rIl0sWyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0Il0sWyJnZXRQYXNzU3R5bGVDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIl0sWyJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaW50ZXJzZWN0UmFua0NvdmVycyJdLFsidW5pb25SYW5rQ292ZXJzIiwidW5pb25SYW5rQ292ZXJzIl1dLCJAZW5kby9wYXNzLXN0eWxlIjpbWyJkZWVwbHlGdWxmaWxsZWQiLCJkZWVwbHlGdWxmaWxsZWQiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlUGFzc2FibGUuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImlzRW5jb2RlZFJlbW90YWJsZSIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsIm1ha2VFbmNvZGVQYXNzYWJsZSIsIm1ha2VQYXNzYWJsZUtpdCIsInBhc3NTdHlsZVByZWZpeGVzIiwicmVjb3JkTmFtZXMiLCJyZWNvcmRWYWx1ZXMiLCJ6ZXJvUGFkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldFRhZyxtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGFzc2VydFJlY29yZCxpc0Vycm9yTGlrZSxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLGIscSxGYWlsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiYXNzZXJ0UmVjb3JkXCIsIFskaM2PX2EgPT4gKGFzc2VydFJlY29yZCA9ICRozY9fYSldXSxbXCJpc0Vycm9yTGlrZVwiLCBbJGjNj19hID0+IChpc0Vycm9yTGlrZSA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcImJcIiwgWyRozY9fYSA9PiAoYiA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtmcm9tRW50cmllcyxpc309T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcblxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnRyb2wtcmVnZXgqL1xuY29uc3QgckMwPS9bXFx4MDAtXFx4MUZdLztcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHN1ZmZpeCBvZiBhIHN0cmluZyBzdGFydGluZyBhdCBhIHBhcnRpY3VsYXIgaW5kZXguXG4gKiBUaGlzIGJvdGggZXhwcmVzc2VzIGludGVudCBhbmQgcG90ZW50aWFsbHkgYXZvaWRzIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODRcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyXG4gKiBAcGFyYW0ge251bWJlcn0gaW5kZXhcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGdldFN1ZmZpeD0oc3RyLGluZGV4KT0+aW5kZXg9PT0wP3N0cjpzdHIuc3Vic3RyaW5nKGluZGV4KTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCwgd2UgaGF2ZSBvbmx5XG4gKiBzdHJpbmctbmFtZWQgb3duIHByb3BlcnRpZXMuIGByZWNvcmROYW1lc2AgcmV0dXJucyB0aG9zZSBuYW1lICpyZXZlcnNlKlxuICogc29ydGVkLCBiZWNhdXNlIHRoYXQncyBob3cgcmVjb3JkcyBhcmUgY29tcGFyZWQsIGVuY29kZWQsIGFuZCBzb3J0ZWQuXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZE5hbWVzPShyZWNvcmQpPT5cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNjAjZGlzY3Vzc2lvbl9yMTAwMzY1NzI0NCovXG4vKiBjb21wYXJlcyB0d28gd2F5cyBvZiByZXZlcnNlIHNvcnRpbmcsIGFuZCBzaG93cyB0aGF0IGAuc29ydCgpLnJldmVyc2UoKWAqL1xuLyogaXMgY3VycmVudGx5IGZhc3RlciBvbiBNb2RkYWJsZSBYUywgd2hpbGUgdGhlIG90aGVyIHdheSwqL1xuLyogYC5zb3J0KHJldmVyc2VDb21wYXJhdG9yKWAsIGlzIGZhc3RlciBvbiB2OC4gV2UgY3VycmVudGx5IGNhcmUgbW9yZSBhYm91dCovXG4vKiBYUyBwZXJmb3JtYW5jZSwgc28gd2UgcmV2ZXJzZSBzb3J0IHVzaW5nIGAuc29ydCgpLnJldmVyc2UoKWAuKi9cbmhhcmRlbigvKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjb3JkKS5zb3J0KCkucmV2ZXJzZSgpKTskaM2PX29uY2UucmVjb3JkTmFtZXMocmVjb3JkTmFtZXMpO1xuaGFyZGVuKHJlY29yZE5hbWVzKTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCBhbmQgYG5hbWVzYCBpcyBgcmVjb3JkTmFtZXMocmVjb3JkKWAsXG4gKiByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcgYXJyYXkgb2YgcHJvcGVydHkgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxUPn0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBuYW1lc1xuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZFZhbHVlcz0ocmVjb3JkLG5hbWVzKT0+XG5oYXJkZW4obmFtZXMubWFwKChuYW1lKT0+cmVjb3JkW25hbWVdKSk7JGjNj19vbmNlLnJlY29yZFZhbHVlcyhyZWNvcmRWYWx1ZXMpO1xuaGFyZGVuKHJlY29yZFZhbHVlcyk7XG5cbmNvbnN0IHplcm9lcz1BcnJheSgxNikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8saSk9PicwJy5yZXBlYXQoaSkpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gblxuICogQHBhcmFtIHtudW1iZXJ9IHNpemVcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICB6ZXJvUGFkPShuLHNpemUpPT57XG5jb25zdCBuU3RyPSBgJHtufWA7XG5jb25zdCBmaWxsTGVuPXNpemUtblN0ci5sZW5ndGg7XG5pZihmaWxsTGVuPT09MClyZXR1cm4gblN0cjtcbmFzc2VydChmaWxsTGVuPjAmJmZpbGxMZW48emVyb2VzLmxlbmd0aCk7XG5yZXR1cm4gYCR7emVyb2VzW2ZpbGxMZW5dfSR7blN0cn1gO1xuIH07JGjNj19vbmNlLnplcm9QYWQoemVyb1BhZCk7XG5oYXJkZW4oemVyb1BhZCk7XG5cbi8qIFRoaXMgaXMgdGhlIEphdmFTY3JpcHQgYW5hbG9nIHRvIGEgQyB1bmlvbjogYSB3YXkgdG8gbWFwIGJldHdlZW4gYSBmbG9hdCBhcyBhKi9cbi8qIG51bWJlciBhbmQgdGhlIGJpdHMgdGhhdCByZXByZXNlbnQgdGhlIGZsb2F0IGFzIGEgYnVmZmVyIGZ1bGwgb2YgYnl0ZXMuICBOb3RlKi9cbi8qIHRoYXQgdGhlIG11dGF0aW9uIG9mIHN0YXRpYyBzdGF0ZSBoZXJlIG1ha2VzIHRoaXMgaW52YWxpZCBKZXNzaWUgY29kZSwgYnV0Ki9cbi8qIGRvaW5nIGl0IHRoaXMgd2F5IHNhdmVzIHRoZSBudWdhdG9yeSBhbmQgZ3JhdHVpdG91cyBhbGxvY2F0aW9ucyB0aGF0IHdvdWxkKi9cbi8qIGhhcHBlbiBldmVyeSB0aW1lIHlvdSBkbyBhIGNvbnZlcnNpb24gLS0gYW5kIGluIHByYWN0aWNhbCB0ZXJtcyBpdCdzIHNhZmUqL1xuLyogYmVjYXVzZSB3ZSBwdXQgdGhlIHZhbHVlIGluIG9uZSBzaWRlIGFuZCB0aGVuIGltbWVkaWF0ZWx5IHRha2UgaXQgb3V0IHRoZSovXG4vKiBvdGhlcjsgdGhlcmUgaXMgbm8gYWN0dWFsIHN0YXRlIHJldGFpbmVkIGluIHRoZSBjbGFzc2ljIHNlbnNlIGFuZCB0aHVzIG5vKi9cbi8qIHJlLWVudHJhbmN5IGlzc3VlLiovXG5jb25zdCBhc051bWJlcj1uZXcgRmxvYXQ2NEFycmF5KDEpO1xuY29uc3QgYXNCaXRzPW5ldyBCaWdVaW50NjRBcnJheShhc051bWJlci5idWZmZXIpO1xuXG4vKiBKYXZhU2NyaXB0IG51bWJlcnMgYXJlIGVuY29kZWQgYnkgb3V0cHV0dGluZyB0aGUgYmFzZS0xNiovXG4vKiByZXByZXNlbnRhdGlvbiBvZiB0aGUgYmluYXJ5IHZhbHVlIG9mIHRoZSB1bmRlcmx5aW5nIElFRUUgZmxvYXRpbmcgcG9pbnQqL1xuLyogcmVwcmVzZW50YXRpb24uICBGb3IgbmVnYXRpdmUgdmFsdWVzLCBhbGwgYml0cyBvZiB0aGlzIHJlcHJlc2VudGF0aW9uIGFyZSovXG4vKiBjb21wbGVtZW50ZWQgcHJpb3IgdG8gdGhlIGJhc2UtMTYgY29udmVyc2lvbiwgd2hpbGUgZm9yIHBvc2l0aXZlIHZhbHVlcywgdGhlKi9cbi8qIHNpZ24gYml0IGlzIGNvbXBsZW1lbnRlZC4gIFRoaXMgZW5zdXJlcyBib3RoIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYmVmb3JlKi9cbi8qIHBvc2l0aXZlIHZhbHVlcyBhbmQgdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgc29ydCBhY2NvcmRpbmcgdG8gdGhlaXIgbmVnYXRpdmUqL1xuLyogbWFnbml0dWRlIHJhdGhlciB0aGFuIHRoZWlyIHBvc2l0aXZlIG1hZ25pdHVkZS4gIFRoaXMgcmVzdWx0cyBpbiBhbiBBU0NJSSovXG4vKiBlbmNvZGluZyB3aG9zZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgaXMgdGhlIHNhbWUgYXMgdGhlIG51bWVyaWMgc29ydCBvcmRlciovXG4vKiBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLiovXG5cbi8qIFRPRE8gQ2hvb3NlIHRoZSBzYW1lIGNhbm9uaWNhbCBOYU4gZW5jb2RpbmcgdGhhdCBjb3NtV2FzbSBhbmQgZXdhc20gY2hvc2UuKi9cbmNvbnN0IENhbm9uaWNhbE5hTkJpdHM9J2ZmZjgwMDAwMDAwMDAwMDAnO1xuXG4vKipcbiAqIEBwYXJhbSB7bnVtYmVyfSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaW5hcnk2ND0obik9Pntcbi8qIE5vcm1hbGl6ZSAtMCB0byAwIGFuZCBOYU4gdG8gYSBjYW5vbmljYWwgZW5jb2RpbmcqL1xuaWYoaXMobiwtMCkpe1xubj0wO1xuIH1lbHNlIGlmKGlzKG4sTmFOKSl7XG5yZXR1cm4gYGYke0Nhbm9uaWNhbE5hTkJpdHN9YDtcbiB9XG5hc051bWJlclswXT1uO1xubGV0IGJpdHM9YXNCaXRzWzBdO1xuaWYobjwwKXtcbmJpdHNePTB4ZmZmZmZmZmZmZmZmZmZmZm47XG4gfWVsc2V7XG5iaXRzXj0weDgwMDAwMDAwMDAwMDAwMDBuO1xuIH1cbnJldHVybiBgZiR7emVyb1BhZChiaXRzLnRvU3RyaW5nKDE2KSwxNil9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGVCaW5hcnk2ND0oZW5jb2RlZCxza2lwPTApPT57XG5lbmNvZGVkLmNoYXJBdChza2lwKT09PSdmJ3x8RmFpbCBgRW5jb2RlZCBudW1iZXIgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IGJpdHM9QmlnSW50KCBgMHgke2dldFN1ZmZpeChlbmNvZGVkLHNraXArMSl9YCk7XG5pZihlbmNvZGVkLmNoYXJBdChza2lwKzEpPCc4Jyl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5hc0JpdHNbMF09Yml0cztcbmNvbnN0IHJlc3VsdD1hc051bWJlclswXTtcbiFpcyhyZXN1bHQsLTApfHxcbkZhaWwgYFVuZXhwZWN0ZWQgbmVnYXRpdmUgemVybzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEVuY29kZSBhIEphdmFTY3JpcHQgYmlnaW50IHVzaW5nIGEgdmFyaWFudCBvZiBFbGlhcyBkZWx0YSBjb2RpbmcsIHdpdGggYW5cbiAqIGluaXRpYWwgY29tcG9uZW50IGZvciB0aGUgbGVuZ3RoIG9mIHRoZSBkaWdpdCBjb3VudCBhcyBhIHVuYXJ5IHN0cmluZywgYVxuICogc2Vjb25kIGNvbXBvbmVudCBmb3IgdGhlIGRlY2ltYWwgZGlnaXQgY291bnQsIGFuZCBhIHRoaXJkIGNvbXBvbmVudCBmb3IgdGhlXG4gKiBkZWNpbWFsIGRpZ2l0cyBwcmVjZWRlZCBieSBhIGdyYXR1aXRvdXMgc2VwYXJhdGluZyBjb2xvbi5cbiAqIFRvIGVuc3VyZSB0aGF0IHRoZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgb2YgZW5jb2RlZCB2YWx1ZXMgbWF0Y2hlcyB0aGVcbiAqIG51bWVyaWMgc29ydCBvcmRlciBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLCB0aGUgY2hhcmFjdGVycyBvZiB0aGUgdW5hcnlcbiAqIHByZWZpeCBhcmUgZGlmZmVyZW50IGZvciBuZWdhdGl2ZSB2YWx1ZXMgKHR5cGUgXCJuXCIgZm9sbG93ZWQgYnkgYW55IG51bWJlciBvZlxuICogXCIjXCJzIFt3aGljaCBzb3J0IGJlZm9yZSBkZWNpbWFsIGRpZ2l0c10pIHZzLiBwb3NpdGl2ZSBhbmQgemVybyB2YWx1ZXMgKHR5cGVcbiAqIFwicFwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2YgXCJ+XCJzIFt3aGljaCBzb3J0IGFmdGVyIGRlY2ltYWwgZGlnaXRzXSkgYW5kXG4gKiBlYWNoIGRlY2ltYWwgZGlnaXQgb2YgdGhlIGVuY29kaW5nIGZvciBhIG5lZ2F0aXZlIHZhbHVlIGlzIHJlcGxhY2VkIHdpdGggaXRzXG4gKiB0ZW4ncyBjb21wbGVtZW50IChzbyB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBvZiB0aGUgc2FtZSBzY2FsZSBzb3J0IGJ5XG4gKiAqZGVzY2VuZGluZyogYWJzb2x1dGUgdmFsdWUpLlxuICpcbiAqIEBwYXJhbSB7YmlnaW50fSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaWdJbnQ9KG4pPT57XG5jb25zdCBhYnM9bjwwbj8tbjpuO1xuY29uc3QgbkRpZ2l0cz1hYnMudG9TdHJpbmcoKS5sZW5ndGg7XG5jb25zdCBsRGlnaXRzPW5EaWdpdHMudG9TdHJpbmcoKS5sZW5ndGg7XG5pZihuPDBuKXtcbnJldHVybiBgbiR7XG4vKiBBIFwiI1wiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJyMnLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgY291bnQgb2YgZGlnaXRzLiovXG4oMTAqKmxEaWdpdHMtbkRpZ2l0cykudG9TdHJpbmcoKS5wYWRTdGFydChsRGlnaXRzLCcwJylcbiB9OiR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgZGlnaXRzLiovXG4oMTBuKipCaWdJbnQobkRpZ2l0cykrbikudG9TdHJpbmcoKS5wYWRTdGFydChuRGlnaXRzLCcwJylcbiB9YDtcbiB9ZWxzZXtcbnJldHVybiBgcCR7XG4vKiBBIFwiflwiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJ34nLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgY291bnQgb2YgZGlnaXRzLiovXG5uRGlnaXRzXG4gfToke1xuLyogVGhlIGRpZ2l0cy4qL1xublxuIH1gO1xuIH1cbiB9O1xuXG5jb25zdCByQmlnSW50UGF5bG9hZD0vKFswLTldKykoOihbMC05XSskfCl8KS9zO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5jb25zdCBkZWNvZGVCaWdJbnQ9KGVuY29kZWQpPT57XG5jb25zdCB0eXBlUHJlZml4PWVuY29kZWQuY2hhckF0KDApOy8qIGZhc3RlciB0aGFuIGVuY29kZWRbMF0qL1xudHlwZVByZWZpeD09PSdwJ3x8XG50eXBlUHJlZml4PT09J24nfHxcbkZhaWwgYEVuY29kZWQgYmlnaW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcblxuY29uc3R7XG5pbmRleDpsRGlnaXRzLFxuMTpzbkRpZ2l0cyxcbjI6dGFpbCxcbjM6ZGlnaXRzfT1cbmVuY29kZWQubWF0Y2gockJpZ0ludFBheWxvYWQpfHxGYWlsIGBEaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5cbnNuRGlnaXRzLmxlbmd0aD09PWxEaWdpdHN8fFxuRmFpbCBgVW5hcnktcHJlZml4ZWQgZGVjaW1hbCBkaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgbkRpZ2l0cz1wYXJzZUludChzbkRpZ2l0cywxMCk7XG5pZih0eXBlUHJlZml4PT09J24nKXtcbi8qIFRPRE8gQXNzZXJ0IHRvIHJlamVjdCBmb3JiaWRkZW4gZW5jb2RpbmdzKi9cbi8qIGxpa2UgXCJuMDpcIiBhbmQgXCJuMDA64oCmXCIgYW5kIFwibjkxOuKAplwiIHRocm91Z2ggXCJuOTk64oCmXCI/Ki9cbm5EaWdpdHM9MTAqKi8qKiBAdHlwZSB7bnVtYmVyfSAqL2xEaWdpdHMtbkRpZ2l0cztcbiB9XG5cbnRhaWwuY2hhckF0KDApPT09JzonfHxGYWlsIGBTZXBhcmF0b3IgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xuZGlnaXRzLmxlbmd0aD09PW5EaWdpdHN8fFxuRmFpbCBgRml4ZWQtbGVuZ3RoIGRpZ2l0IHNlcXVlbmNlIGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmxldCBuPUJpZ0ludChkaWdpdHMpO1xuaWYodHlwZVByZWZpeD09PSduJyl7XG4vKiBUT0RPIEFzc2VydCB0byByZWplY3QgZm9yYmlkZGVuIGVuY29kaW5ncyovXG4vKiBsaWtlIFwibjk6MFwiIGFuZCBcIm44OjAwXCIgYW5kIFwibjg6OTFcIiB0aHJvdWdoIFwibjg6OTlcIj8qL1xubj0tKDEwbioqQmlnSW50KG5EaWdpdHMpLW4pO1xuIH1cblxucmV0dXJuIG47XG4gfTtcblxuLyoqXG4gKiBBIHNwYXJzZSBhcnJheSBmb3Igd2hpY2ggZXZlcnkgcHJlc2VudCBpbmRleCBtYXBzIGEgY29kZSBwb2ludCBpbiB0aGUgQVNDSUlcbiAqIHJhbmdlIHRvIGEgY29ycmVzcG9uZGluZyBlc2NhcGUgc2VxdWVuY2UuXG4gKlxuICogRXNjYXBlcyBhbGwgY2hhcmFjdGVycyBmcm9tIFUrMDAwMCBOVUxMIHRvIFUrMDAxRiBJTkZPUk1BVElPTiBTRVBBUkFUT1IgT05FXG4gKiBsaWtlIGAhPGNoYXJhY3RlciBvZmZzZXQgYnkgMHgyMT5gIHRvIGF2b2lkIEpTT04uc3RyaW5naWZ5IGV4cGFuc2lvbiBhc1xuICogYFxcdUhISEhgLCBhbmQgc3BlY2lhbGx5IGVzY2FwZXMgVSswMDIwIFNQQUNFICh0aGUgYXJyYXkgZWxlbWVudCB0ZXJtaW5hdG9yKVxuICogYXMgYCFfYCBhbmQgVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgKHRoZSBlc2NhcGUgcHJlZml4KSBhcyBgIXxgIChib3RoIGNob3NlblxuICogZm9yIHZpc3VhbCBhcHByb3hpbWF0aW9uKS5cbiAqIFJlbGF0aXZlIGxleGljb2dyYXBoaWMgb3JkZXJpbmcgaXMgcHJlc2VydmVkIGJ5IHRoaXMgbWFwcGluZyBvZiBhbnkgY2hhcmFjdGVyXG4gKiBhdCBvciBiZWZvcmUgYCFgIGluIHRoZSBjb250aWd1b3VzIHJhbmdlIFsweDAwLi4weDIxXSB0byBhIHJlc3BlY3RpdmVcbiAqIGNoYXJhY3RlciBpbiBbMHgyMS4uMHg0MCwgMHg1RiwgMHg3Q10gcHJlY2VkZWQgYnkgYCFgICh3aGljaCBpcyBpdHNlbGYgaW4gdGhlXG4gKiByZXBsYWNlZCByYW5nZSkuXG4gKiBTaW1pbGFybHksIGVzY2FwZXMgYF5gIGFzIGBfQGAgYW5kIGBfYCBhcyBgX19gIGJlY2F1c2UgYF5gIGluZGljYXRlcyB0aGVcbiAqIHN0YXJ0IG9mIGFuIGVuY29kZWQgYXJyYXkuXG4gKlxuICogQHR5cGUge0FycmF5PHN0cmluZz59XG4gKi9cbmNvbnN0IHN0cmluZ0VzY2FwZXM9QXJyYXkoMHgyMikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8sY3ApPT57XG5zd2l0Y2goU3RyaW5nLmZyb21DaGFyQ29kZShjcCkpe1xuY2FzZScgJzpcbnJldHVybichXyc7XG5jYXNlJyEnOlxucmV0dXJuJyF8JztcbmRlZmF1bHQ6XG5yZXR1cm4gYCEke1N0cmluZy5mcm9tQ2hhckNvZGUoY3ArMHgyMSl9YDt9XG5cbiB9KTtcbnN0cmluZ0VzY2FwZXNbJ14nLmNoYXJDb2RlQXQoMCldPSdfQCc7XG5zdHJpbmdFc2NhcGVzWydfJy5jaGFyQ29kZUF0KDApXT0nX18nO1xuXG4vKipcbiAqIEVuY29kZXMgYSBzdHJpbmcgd2l0aCBlc2NhcGUgc2VxdWVuY2VzIGZvciB1c2UgaW4gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhzdHI6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVDb21wYWN0U3RyaW5nU3VmZml4PShzdHIpPT5cbnN0ci5yZXBsYWNlKC9bXFwwLSFeX10vZywoY2gpPT5zdHJpbmdFc2NhcGVzW2NoLmNoYXJDb2RlQXQoMCldKTtcblxuLyoqXG4gKiBEZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhlbmNvZGVkOiBzdHJpbmcpID0+IHN0cmluZ31cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeD0oZW5jb2RlZCk9PntcbnJldHVybiBlbmNvZGVkLnJlcGxhY2UoLyhbXFwwLSFfXSkoLnxcXG4pPy9nLChlc2MscHJlZml4LHN1ZmZpeCk9PntcbnN3aXRjaChlc2Mpe1xuY2FzZSchXyc6XG5yZXR1cm4nICc7XG5jYXNlJyF8JzpcbnJldHVybichJztcbmNhc2UnX0AnOlxucmV0dXJuJ14nO1xuY2FzZSdfXyc6XG5yZXR1cm4nXyc7XG5kZWZhdWx0OntcbmNvbnN0IGNoPS8qKiBAdHlwZSB7c3RyaW5nfSAqL3N1ZmZpeDtcbi8qIFRoZSByYW5nZSBvZiB2YWxpZCBgIWAtZXNjYXBlIHN1ZmZpeGVzIGlzIFsoMHgwMCsweDIxKS4uKDB4MUYrMHgyMSldLCBpLmUuKi9cbi8qIFsweDIxLi4weDQwXSAoVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgdG8gVSswMDQwIENPTU1FUkNJQUwgQVQpLiovXG5wcmVmaXg9PT0nIScmJnN1ZmZpeCE9PXVuZGVmaW5lZCYmY2g+PSchJyYmY2g8PSdAJ3x8XG5GYWlsIGBpbnZhbGlkIHN0cmluZyBlc2NhcGU6ICR7cShlc2MpfWA7XG5yZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZShjaC5jaGFyQ29kZUF0KDApLTB4MjEpO1xuIH19XG5cbiB9KTtcbiB9O1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1lbmNvZGVzIGEgc3RyaW5nIGZvciB1c2UgaW4gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IGVuY29kZUxlZ2FjeVN0cmluZ1N1ZmZpeD0oc3RyKT0+c3RyO1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1kZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBkZWNvZGVMZWdhY3lTdHJpbmdTdWZmaXg9KGVuY29kZWQpPT5lbmNvZGVkO1xuXG4vKipcbiAqIEVuY29kZXMgYW4gYXJyYXkgaW50byBhIHNlcXVlbmNlIG9mIGVuY29kZWQgZWxlbWVudHMgZm9yIHVzZSBpbiB0aGUgXCJjb21wYWN0T3JkZXJlZFwiXG4gKiBmb3JtYXQsIGVhY2ggdGVybWluYXRlZCBieSBhIHNwYWNlICh3aGljaCBpcyBwYXJ0IG9mIHRoZSBlc2NhcGVkIHJhbmdlIGluXG4gKiBcImNvbXBhY3RPcmRlcmVkXCIgZW5jb2RlZCBzdHJpbmdzKS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQ29tcGFjdEFycmF5PShhcnJheSxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IGNoYXJzPVsnXiddO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgYXJyYXkpe1xuY29uc3QgZW5jPWVuY29kZVBhc3NhYmxlKGVsZW1lbnQpO1xuY2hhcnMucHVzaChlbmMsJyAnKTtcbiB9XG5yZXR1cm4gY2hhcnMuam9pbignJyk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHBhcmFtIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX0gZGVjb2RlUGFzc2FibGVcbiAqIEBwYXJhbSB7bnVtYmVyfSBbc2tpcF1cbiAqIEByZXR1cm5zIHtBcnJheX1cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdEFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xubGV0IGRlcHRoPTA7XG4vKiBTY2FuIGVuY29kZWQgcmF0aGVyIHRoYW4gaXRzIHRhaWwgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmxldCBuZXh0SW5kZXg9c2tpcCsxO1xubGV0IGN1cnJlbnRFbGVtZW50U3RhcnQ9c2tpcCsxO1xuZm9yKGNvbnN0ezA6Y2gsaW5kZXg6aX1vZiBlbmNvZGVkLm1hdGNoQWxsKC9bXFxeIF0vZykpe1xuY29uc3QgaW5kZXg9LyoqIEB0eXBlIHtudW1iZXJ9ICovaTtcbmlmKGluZGV4PD1za2lwKXtcbmlmKGluZGV4PT09c2tpcCl7XG5jaD09PSdeJ3x8RmFpbCBgRW5jb2RlZCBhcnJheSBleHBlY3RlZDogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuIH1cbiB9ZWxzZSBpZihjaD09PSdeJyl7XG4vKiBUaGlzIGlzIHRoZSBzdGFydCBvZiBhIG5lc3RlZCBhcnJheS4qL1xuLyogVE9ETzogU2luY2UgdGhlIHN5bnRheCBvZiBuZXN0ZWQgYXJyYXlzIG11c3QgYmUgdmFsaWRhdGVkIGFzIHBhcnQgb2YqL1xuLyogZGVjb2RpbmcgdGhlIG91dGVyIG9uZSwgY29uc2lkZXIgZGVjb2RpbmcgdGhlbSBoZXJlIGludG8gYSBzaGFyZWQgY2FjaGUqL1xuLyogcmF0aGVyIHRoYW4gZGlzY2FyZGluZyBpbmZvcm1hdGlvbiBhYm91dCB0aGVpciBjb250ZW50cyB1bnRpbCB0aGUgbGF0ZXIqL1xuLyogZGVjb2RlUGFzc2FibGUuKi9cbmRlcHRoKz0xO1xuIH1lbHNle1xuLyogVGhpcyBpcyBhIHRlcm1pbmF0ZWQgZWxlbWVudC4qL1xuaWYoaW5kZXg9PT1uZXh0SW5kZXgpe1xuLyogQSB0ZXJtaW5hdG9yIGFmdGVyIGBbYCBvciBhbiBhbm90aGVyIHRlcm1pbmF0b3IgaW5kaWNhdGVzIHRoYXQgYW4gYXJyYXkgaXMgZG9uZS4qL1xuZGVwdGgtPTE7XG5kZXB0aD49MHx8XG4vKiBwcmV0dGllci1pZ25vcmUqL1xuRmFpbCBgdW5leHBlY3RlZCBhcnJheSBlbGVtZW50IHRlcm1pbmF0b3I6ICR7ZW5jb2RlZC5zbGljZShza2lwLGluZGV4KzIpfWA7XG4gfVxuaWYoZGVwdGg9PT0wKXtcbi8qIFdlIGhhdmUgYSBjb21wbGV0ZSBlbGVtZW50IG9mIHRoZSB0b3Btb3N0IGFycmF5LiovXG5lbGVtZW50cy5wdXNoKFxuZGVjb2RlUGFzc2FibGUoZW5jb2RlZC5zbGljZShjdXJyZW50RWxlbWVudFN0YXJ0LGluZGV4KSkpO1xuXG5jdXJyZW50RWxlbWVudFN0YXJ0PWluZGV4KzE7XG4gfVxuIH1cbi8qIEFkdmFuY2UgdGhlIGluZGV4LiovXG5uZXh0SW5kZXg9aW5kZXgrMTtcbiB9XG5kZXB0aD09PTB8fEZhaWwgYHVudGVybWluYXRlZCBhcnJheTogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xubmV4dEluZGV4PT09ZW5jb2RlZC5sZW5ndGh8fFxuRmFpbCBgdW50ZXJtaW5hdGVkIGFycmF5IGVsZW1lbnQ6ICR7Z2V0U3VmZml4KFxuZW5jb2RlZCxcbmN1cnJlbnRFbGVtZW50U3RhcnQpXG4gfWA7XG5yZXR1cm4gaGFyZGVuKGVsZW1lbnRzKTtcbiB9O1xuXG4vKipcbiAqIFBlcmZvcm1zIHRoZSBvcmlnaW5hbCBhcnJheSBlbmNvZGluZywgd2hpY2ggZXNjYXBlcyBhbGwgZW5jb2RlZCBhcnJheVxuICogZWxlbWVudHMgcmF0aGVyIHRoYW4ganVzdCBzdHJpbmdzIChgXFx1MDAwMGAgYXMgdGhlIGVsZW1lbnQgdGVybWluYXRvciBhbmRcbiAqIGBcXHUwMDAxYCBhcyB0aGUgZXNjYXBlIHByZWZpeCBmb3IgYFxcdTAwMDBgIG9yIGBcXHUwMDAxYCkuXG4gKiBUaGlzIG5lY2Vzc2l0YXRlZCBhbiB1bmRlc2lyYWJsZSBhbW91bnQgb2YgaXRlcmF0aW9uIGFuZCBleHBhbnNpb247IHNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI2MCNkaXNjdXNzaW9uX3I5NjAzNjk4MjZcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlTGVnYWN5QXJyYXk9KGFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgY2hhcnM9WydbJ107XG5mb3IoY29uc3QgZWxlbWVudCBvZiBhcnJheSl7XG5jb25zdCBlbmM9ZW5jb2RlUGFzc2FibGUoZWxlbWVudCk7XG5mb3IoY29uc3QgYyBvZiBlbmMpe1xuaWYoYz09PSdcXHUwMDAwJ3x8Yz09PSdcXHUwMDAxJyl7XG5jaGFycy5wdXNoKCdcXHUwMDAxJyk7XG4gfVxuY2hhcnMucHVzaChjKTtcbiB9XG5jaGFycy5wdXNoKCdcXHUwMDAwJyk7XG4gfVxucmV0dXJuIGNoYXJzLmpvaW4oJycpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gUGFzc2FibGV9IGRlY29kZVBhc3NhYmxlXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7QXJyYXl9XG4gKi9cbmNvbnN0IGRlY29kZUxlZ2FjeUFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xuY29uc3QgZWxlbUNoYXJzPVtdO1xuLyogVXNlIGEgc3RyaW5nIGl0ZXJhdG9yIHRvIGF2b2lkIHNsb3cgaW5kZXhlZCBhY2Nlc3MgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5sZXQgc3RpbGxUb1NraXA9c2tpcCsxO1xubGV0IGluRXNjYXBlPWZhbHNlO1xuZm9yKGNvbnN0IGMgb2YgZW5jb2RlZCl7XG5pZihzdGlsbFRvU2tpcD4wKXtcbnN0aWxsVG9Ta2lwLT0xO1xuaWYoc3RpbGxUb1NraXA9PT0wKXtcbmM9PT0nWyd8fEZhaWwgYEVuY29kZWQgYXJyYXkgZXhwZWN0ZWQ6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbiB9XG4gfWVsc2UgaWYoaW5Fc2NhcGUpe1xuYz09PSdcXHUwMDAwJ3x8XG5jPT09J1xcdTAwMDEnfHxcbkZhaWwgYFVuZXhwZWN0ZWQgY2hhcmFjdGVyIGFmdGVyIHUwMDAxIGVzY2FwZTogJHtjfWA7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDAnKXtcbmNvbnN0IGVuY29kZWRFbGVtZW50PWVsZW1DaGFycy5qb2luKCcnKTtcbmVsZW1DaGFycy5sZW5ndGg9MDtcbmNvbnN0IGVsZW1lbnQ9ZGVjb2RlUGFzc2FibGUoZW5jb2RlZEVsZW1lbnQpO1xuZWxlbWVudHMucHVzaChlbGVtZW50KTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDEnKXtcbmluRXNjYXBlPXRydWU7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tY29udGludWUqL1xuY29udGludWU7XG4gfWVsc2V7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9XG5pbkVzY2FwZT1mYWxzZTtcbiB9XG4haW5Fc2NhcGV8fEZhaWwgYHVuZXhwZWN0ZWQgZW5kIG9mIGVuY29kaW5nICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmVsZW1DaGFycy5sZW5ndGg9PT0wfHxcbkZhaWwgYGVuY29kaW5nIHRlcm1pbmF0ZWQgZWFybHk6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbnJldHVybiBoYXJkZW4oZWxlbWVudHMpO1xuIH07XG5cbmNvbnN0IGVuY29kZVJlY29yZD0ocmVjb3JkLGVuY29kZUFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgbmFtZXM9cmVjb3JkTmFtZXMocmVjb3JkKTtcbmNvbnN0IHZhbHVlcz1yZWNvcmRWYWx1ZXMocmVjb3JkLG5hbWVzKTtcbnJldHVybiBgKCR7ZW5jb2RlQXJyYXkoaGFyZGVuKFtuYW1lcyx2YWx1ZXNdKSxlbmNvZGVQYXNzYWJsZSl9YDtcbiB9O1xuXG5jb25zdCBkZWNvZGVSZWNvcmQ9KGVuY29kZWQsZGVjb2RlQXJyYXksZGVjb2RlUGFzc2FibGUsc2tpcD0wKT0+e1xuYXNzZXJ0KGVuY29kZWQuY2hhckF0KHNraXApPT09JygnKTtcbi8qIFNraXAgdGhlIFwiKFwiIGluc2lkZSBgZGVjb2RlQXJyYXlgIHRvIGF2b2lkIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5jb25zdCB1bnppcHBlZEVudHJpZXM9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudW56aXBwZWRFbnRyaWVzLmxlbmd0aD09PTJ8fFxuRmFpbCBgZXhwZWN0ZWQga2V5cyx2YWx1ZXMgcGFpcjogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuY29uc3Rba2V5cyx2YWxzXT11bnppcHBlZEVudHJpZXM7XG5cbnBhc3NTdHlsZU9mKGtleXMpPT09J2NvcHlBcnJheScmJlxucGFzc1N0eWxlT2YodmFscyk9PT0nY29weUFycmF5JyYmXG5rZXlzLmxlbmd0aD09PXZhbHMubGVuZ3RoJiZcbmtleXMuZXZlcnkoKGtleSk9PnR5cGVvZiBrZXk9PT0nc3RyaW5nJyl8fFxuRmFpbCBgbm90IGEgdmFsaWQgcmVjb3JkIGVuY29kaW5nOiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG5jb25zdCBtYXBFbnRyaWVzPWtleXMubWFwKChrZXksaSk9PltrZXksdmFsc1tpXV0pO1xuY29uc3QgcmVjb3JkPWhhcmRlbihmcm9tRW50cmllcyhtYXBFbnRyaWVzKSk7XG5hc3NlcnRSZWNvcmQocmVjb3JkLCdkZWNvZGVkIHJlY29yZCcpO1xucmV0dXJuIHJlY29yZDtcbiB9O1xuXG5jb25zdCBlbmNvZGVUYWdnZWQ9KHRhZ2dlZCxlbmNvZGVBcnJheSxlbmNvZGVQYXNzYWJsZSk9PlxuIGA6JHtlbmNvZGVBcnJheShoYXJkZW4oW2dldFRhZyh0YWdnZWQpLHRhZ2dlZC5wYXlsb2FkXSksZW5jb2RlUGFzc2FibGUpfWA7XG5cbmNvbnN0IGRlY29kZVRhZ2dlZD0oZW5jb2RlZCxkZWNvZGVBcnJheSxkZWNvZGVQYXNzYWJsZSxza2lwPTApPT57XG5hc3NlcnQoZW5jb2RlZC5jaGFyQXQoc2tpcCk9PT0nOicpO1xuLyogU2tpcCB0aGUgXCI6XCIgaW5zaWRlIGBkZWNvZGVBcnJheWAgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmNvbnN0IHRhZ2dlZFBheWxvYWQ9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudGFnZ2VkUGF5bG9hZC5sZW5ndGg9PT0yfHxcbkZhaWwgYGV4cGVjdGVkIHRhZyxwYXlsb2FkIHBhaXI6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmNvbnN0W3RhZyxwYXlsb2FkXT10YWdnZWRQYXlsb2FkO1xucGFzc1N0eWxlT2YodGFnKT09PSdzdHJpbmcnfHxcbkZhaWwgYG5vdCBhIHZhbGlkIHRhZ2dlZCBlbmNvZGluZzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLHBheWxvYWQpO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVSZW1vdGFibGU9KHVuc2FmZUVuY29kZVJlbW90YWJsZSx2ZXJpZnlFbmNvZGluZyk9PntcbmNvbnN0IGVuY29kZVJlbW90YWJsZT0ocixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVJlbW90YWJsZShyLGlubmVyRW5jb2RlKTtcbnR5cGVvZiBlbmNvZGluZz09PSdzdHJpbmcnJiZlbmNvZGluZy5jaGFyQXQoMCk9PT0ncid8fFxuRmFpbCBgUmVtb3RhYmxlIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcInJcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ1JlbW90YWJsZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUmVtb3RhYmxlO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVQcm9taXNlPSh1bnNhZmVFbmNvZGVQcm9taXNlLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlUHJvbWlzZT0ocCxpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVByb21pc2UocCxpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09Jz8nfHxcbkZhaWwgYFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiP1wiOiAke2VuY29kaW5nfWA7XG52ZXJpZnlFbmNvZGluZyhlbmNvZGluZywnUHJvbWlzZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUHJvbWlzZTtcbiB9O1xuXG5jb25zdCBtYWtlRW5jb2RlRXJyb3I9KHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlRXJyb3I9KGVycixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZUVycm9yKGVycixpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09JyEnfHxcbkZhaWwgYEVycm9yIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcIiFcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ0Vycm9yJyk7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfTtcbnJldHVybiBlbmNvZGVFcnJvcjtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVSZW1vdGFibGVdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVQcm9taXNlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVFcnJvcl1cbiAqIEBwcm9wZXJ0eSB7J2xlZ2FjeU9yZGVyZWQnIHwgJ2NvbXBhY3RPcmRlcmVkJ30gW2Zvcm1hdF1cbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9IGVuY29kZVN0cmluZ1N1ZmZpeFxuICogQHBhcmFtIHsoYXJyOiB1bmtub3duW10sIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZykgPT4gc3RyaW5nfSBlbmNvZGVBcnJheVxuICogQHBhcmFtIHtSZXF1aXJlZDxFbmNvZGVPcHRpb25zPiAmIHt2ZXJpZnlFbmNvZGluZz86IChlbmNvZGVkOiBzdHJpbmcsIGxhYmVsOiBzdHJpbmcpID0+IHZvaWR9fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KHA6IFBhc3NhYmxlKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckVuY29kZT0oZW5jb2RlU3RyaW5nU3VmZml4LGVuY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZTp1bnNhZmVFbmNvZGVSZW1vdGFibGUsXG5lbmNvZGVQcm9taXNlOnVuc2FmZUVuY29kZVByb21pc2UsXG5lbmNvZGVFcnJvcjp1bnNhZmVFbmNvZGVFcnJvcixcbnZlcmlmeUVuY29kaW5nPSgpPT57IH19PVxub3B0aW9ucztcbmNvbnN0IGVuY29kZVJlbW90YWJsZT1tYWtlRW5jb2RlUmVtb3RhYmxlKFxudW5zYWZlRW5jb2RlUmVtb3RhYmxlLFxudmVyaWZ5RW5jb2RpbmcpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlPW1ha2VFbmNvZGVQcm9taXNlKHVuc2FmZUVuY29kZVByb21pc2UsdmVyaWZ5RW5jb2RpbmcpO1xuY29uc3QgZW5jb2RlRXJyb3I9bWFrZUVuY29kZUVycm9yKHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKTtcblxuY29uc3QgaW5uZXJFbmNvZGU9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gZW5jb2RlRXJyb3IocGFzc2FibGUsaW5uZXJFbmNvZGUpO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXNzYWJsZSk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnbnVsbCc6e1xucmV0dXJuJ3YnO1xuIH1cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm4neic7XG4gfVxuY2FzZSdudW1iZXInOntcbnJldHVybiBlbmNvZGVCaW5hcnk2NChwYXNzYWJsZSk7XG4gfVxuY2FzZSdzdHJpbmcnOntcbnJldHVybiBgcyR7ZW5jb2RlU3RyaW5nU3VmZml4KHBhc3NhYmxlKX1gO1xuIH1cbmNhc2UnYm9vbGVhbic6e1xucmV0dXJuIGBiJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gZW5jb2RlQmlnSW50KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xucmV0dXJuIGVuY29kZVJlbW90YWJsZShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIGVuY29kZUVycm9yKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBlbmNvZGVQcm9taXNlKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuLyogU3RyaW5ncyBhbmQgc3ltYm9scyBzaGFyZSBlbmNvZGluZyBsb2dpYy4qL1xuY29uc3QgbmFtZT1uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbnJldHVybiBgeSR7ZW5jb2RlU3RyaW5nU3VmZml4KG5hbWUpfWA7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbnJldHVybiBlbmNvZGVBcnJheShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG5yZXR1cm4gZW5jb2RlUmVjb3JkKHBhc3NhYmxlLGVuY29kZUFycmF5LGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJuIGVuY29kZVRhZ2dlZChwYXNzYWJsZSxlbmNvZGVBcnJheSxpbm5lckVuY29kZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBhICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgdXNlZCBhcyBhIGNvbGxlY3Rpb24gcGFzc2FibGVgO1xuIH19XG5cbiB9O1xucmV0dXJuIGlubmVyRW5jb2RlO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yXVxuICovXG5cbmNvbnN0IGxpYmVyYWxEZWNvZGVycz0vKiogQHR5cGUge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSAqL1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL3tcbmRlY29kZVJlbW90YWJsZTooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZCxcbmRlY29kZVByb21pc2U6KF9lbmNvZGluZyxfaW5uZXJEZWNvZGUpPT51bmRlZmluZWQsXG5kZWNvZGVFcnJvcjooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZH07XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfSBkZWNvZGVTdHJpbmdTdWZmaXhcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZywgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlLCBza2lwPzogbnVtYmVyKSA9PiB1bmtub3duW119IGRlY29kZUFycmF5XG4gKiBAcGFyYW0ge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckRlY29kZT0oZGVjb2RlU3RyaW5nU3VmZml4LGRlY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVSZW1vdGFibGUsZGVjb2RlUHJvbWlzZSxkZWNvZGVFcnJvcn09b3B0aW9ucztcbi8qKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9ICovXG5jb25zdCBpbm5lckRlY29kZT0oZW5jb2RlZCxza2lwPTApPT57XG5zd2l0Y2goZW5jb2RlZC5jaGFyQXQoc2tpcCkpe1xuY2FzZSd2Jzp7XG5yZXR1cm4gbnVsbDtcbiB9XG5jYXNlJ3onOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdmJzp7XG5yZXR1cm4gZGVjb2RlQmluYXJ5NjQoZW5jb2RlZCxza2lwKTtcbiB9XG5jYXNlJ3MnOntcbnJldHVybiBkZWNvZGVTdHJpbmdTdWZmaXgoZ2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKSk7XG4gfVxuY2FzZSdiJzp7XG5jb25zdCBzdWJzdHJpbmc9Z2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKTtcbmlmKHN1YnN0cmluZz09PSd0cnVlJyl7XG5yZXR1cm4gdHJ1ZTtcbiB9ZWxzZSBpZihzdWJzdHJpbmc9PT0nZmFsc2UnKXtcbnJldHVybiBmYWxzZTtcbiB9XG50aHJvdyBGYWlsIGBleHBlY3RlZCBlbmNvZGVkIGJvb2xlYW4gdG8gYmUgXCJidHJ1ZVwiIG9yIFwiYmZhbHNlXCI6ICR7c3Vic3RyaW5nfWA7XG4gfVxuY2FzZSduJzpcbmNhc2UncCc6e1xucmV0dXJuIGRlY29kZUJpZ0ludChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSk7XG4gfVxuY2FzZSdyJzp7XG5yZXR1cm4gZGVjb2RlUmVtb3RhYmxlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJz8nOntcbnJldHVybiBkZWNvZGVQcm9taXNlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJyEnOntcbnJldHVybiBkZWNvZGVFcnJvcihnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSxpbm5lckRlY29kZSk7XG4gfVxuY2FzZSd5Jzp7XG4vKiBTdHJpbmdzIGFuZCBzeW1ib2xzIHNoYXJlIGRlY29kaW5nIGxvZ2ljLiovXG5jb25zdCBuYW1lPWRlY29kZVN0cmluZ1N1ZmZpeChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKzEpKTtcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG4gfVxuY2FzZSdbJzpcbmNhc2UnXic6e1xuLyogQHRzLWV4cGVjdC1lcnJvciBUeXBlICd1bmtub3duW10nIGlzIG5vdCBQYXNzYWJsZSovXG5yZXR1cm4gZGVjb2RlQXJyYXkoZW5jb2RlZCxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJygnOntcbnJldHVybiBkZWNvZGVSZWNvcmQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJzonOntcbnJldHVybiBkZWNvZGVUYWdnZWQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYGludmFsaWQgZGF0YWJhc2Uga2V5OiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaW5uZXJEZWNvZGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXNzYWJsZUtpdFxuICogQHByb3BlcnR5IHtSZXR1cm5UeXBlPG1ha2VJbm5lckVuY29kZT59IGVuY29kZVBhc3NhYmxlXG4gKiBAcHJvcGVydHkge1JldHVyblR5cGU8bWFrZUlubmVyRGVjb2RlPn0gZGVjb2RlUGFzc2FibGVcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlT3B0aW9ucyAmIERlY29kZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhc3NhYmxlS2l0PShvcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGU9KHIsXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3J9YCxcbmVuY29kZVByb21pc2U9KHAsXyk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwfWAsXG5lbmNvZGVFcnJvcj0oZXJyLF8pPT5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke2Vycn1gLFxuZm9ybWF0PSdsZWdhY3lPcmRlcmVkJyxcblxuZGVjb2RlUmVtb3RhYmxlPShlbmNvZGluZyxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZVByb21pc2U9KGVuY29kaW5nLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZUVycm9yPShlbmNvZGluZyxfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gfT1cbm9wdGlvbnM7XG5cbi8qKiBAdHlwZSB7UGFzc2FibGVLaXRbJ2VuY29kZVBhc3NhYmxlJ119ICovXG5sZXQgZW5jb2RlUGFzc2FibGU7XG5jb25zdCBlbmNvZGVPcHRpb25zPXtlbmNvZGVSZW1vdGFibGUsZW5jb2RlUHJvbWlzZSxlbmNvZGVFcnJvcixmb3JtYXR9O1xuaWYoZm9ybWF0PT09J2NvbXBhY3RPcmRlcmVkJyl7XG5jb25zdCBsaWJlcmFsRGVjb2RlPW1ha2VJbm5lckRlY29kZShcbmRlY29kZUNvbXBhY3RTdHJpbmdTdWZmaXgsXG5kZWNvZGVDb21wYWN0QXJyYXksXG5saWJlcmFsRGVjb2RlcnMpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGluZ1xuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgdmVyaWZ5RW5jb2Rpbmc9KGVuY29kaW5nLGxhYmVsKT0+e1xuIWVuY29kaW5nLm1hdGNoKHJDMCl8fFxuRmFpbCBgJHtiKFxubGFiZWwpXG4gfSBlbmNvZGluZyBtdXN0IG5vdCBjb250YWluIGEgQzAgY29udHJvbCBjaGFyYWN0ZXI6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRlY29kZWQ9ZGVjb2RlQ29tcGFjdEFycmF5KCBgXnYgJHtlbmNvZGluZ30gdiBgLGxpYmVyYWxEZWNvZGUpO1xuaXNBcnJheShkZWNvZGVkKSYmXG5kZWNvZGVkLmxlbmd0aD09PTMmJlxuZGVjb2RlZFswXT09PW51bGwmJlxuZGVjb2RlZFsyXT09PW51bGx8fFxuRmFpbCBgJHtiKGxhYmVsKX0gZW5jb2RpbmcgbXVzdCBiZSBlbWJlZGRhYmxlOiAke2VuY29kaW5nfWA7XG4gfTtcbmNvbnN0IGVuY29kZUNvbXBhY3Q9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmVuY29kZUNvbXBhY3RBcnJheSxcbnsuLi5lbmNvZGVPcHRpb25zLHZlcmlmeUVuY29kaW5nfSk7XG5cbmVuY29kZVBhc3NhYmxlPShwYXNzYWJsZSk9PiBgfiR7ZW5jb2RlQ29tcGFjdChwYXNzYWJsZSl9YDtcbiB9ZWxzZSBpZihmb3JtYXQ9PT0nbGVnYWN5T3JkZXJlZCcpe1xuZW5jb2RlUGFzc2FibGU9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZW5jb2RlTGVnYWN5QXJyYXksXG5lbmNvZGVPcHRpb25zKTtcblxuIH1lbHNle1xudGhyb3cgRmFpbCBgVW5yZWNvZ25pemVkIGZvcm1hdDogJHtxKGZvcm1hdCl9YDtcbiB9XG5cbmNvbnN0IGRlY29kZU9wdGlvbnM9e2RlY29kZVJlbW90YWJsZSxkZWNvZGVQcm9taXNlLGRlY29kZUVycm9yfTtcbmNvbnN0IGRlY29kZUNvbXBhY3Q9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmRlY29kZUNvbXBhY3RBcnJheSxcbmRlY29kZU9wdGlvbnMpO1xuXG5jb25zdCBkZWNvZGVMZWdhY3k9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZGVjb2RlTGVnYWN5QXJyYXksXG5kZWNvZGVPcHRpb25zKTtcblxuY29uc3QgZGVjb2RlUGFzc2FibGU9KGVuY29kZWQpPT57XG4vKiBBIGxlYWRpbmcgXCJ+XCIgaW5kaWNhdGVzIHRoZSB2MiBlbmNvZGluZyAod2l0aCBlc2NhcGluZyBpbiBzdHJpbmdzIHJhdGhlciB0aGFuIGFycmF5cykuKi9cbi8qIFNraXAgaXQgaW5zaWRlIGBkZWNvZGVDb21wYWN0YCB0byBhdm9pZCBzbG93IGBzdWJzdHJpbmdgIGluIFhTLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODQqL1xuaWYoZW5jb2RlZC5jaGFyQXQoMCk9PT0nficpe1xucmV0dXJuIGRlY29kZUNvbXBhY3QoZW5jb2RlZCwxKTtcbiB9XG5yZXR1cm4gZGVjb2RlTGVnYWN5KGVuY29kZWQpO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe2VuY29kZVBhc3NhYmxlLGRlY29kZVBhc3NhYmxlfSk7XG4gfTskaM2PX29uY2UubWFrZVBhc3NhYmxlS2l0KG1ha2VQYXNzYWJsZUtpdCk7XG5oYXJkZW4obWFrZVBhc3NhYmxlS2l0KTtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0WydlbmNvZGVQYXNzYWJsZSddfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVBhc3NhYmxlPShlbmNvZGVPcHRpb25zKT0+e1xuY29uc3R7ZW5jb2RlUGFzc2FibGV9PW1ha2VQYXNzYWJsZUtpdChlbmNvZGVPcHRpb25zKTtcbnJldHVybiBlbmNvZGVQYXNzYWJsZTtcbiB9OyRozY9fb25jZS5tYWtlRW5jb2RlUGFzc2FibGUobWFrZUVuY29kZVBhc3NhYmxlKTtcbmhhcmRlbihtYWtlRW5jb2RlUGFzc2FibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7RGVjb2RlT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7UGFzc2FibGVLaXRbJ2RlY29kZVBhc3NhYmxlJ119XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlUGFzc2FibGU9KGRlY29kZU9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVQYXNzYWJsZX09bWFrZVBhc3NhYmxlS2l0KGRlY29kZU9wdGlvbnMpO1xucmV0dXJuIGRlY29kZVBhc3NhYmxlO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVQYXNzYWJsZShtYWtlRGVjb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5cbmNvbnN0ICAgICAgICBpc0VuY29kZWRSZW1vdGFibGU9KGVuY29kZWQpPT5lbmNvZGVkLmNoYXJBdCgwKT09PSdyJzskaM2PX29uY2UuaXNFbmNvZGVkUmVtb3RhYmxlKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5oYXJkZW4oaXNFbmNvZGVkUmVtb3RhYmxlKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlIHtSZWNvcmQ8UGFzc1N0eWxlLCBzdHJpbmc+fVxuICogVGhlIHNpbmdsZSBwcmVmaXggY2hhcmFjdGVycyB0byBiZSB1c2VkIGZvciBlYWNoIFBhc3NTdHlsZSBjYXRlZ29yeS5cbiAqIGBiaWdpbnRgIGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBlYWNoIG9mIHRob3NlIGNoYXJhY3RlcnNcbiAqIGluZGl2aWR1YWxseSBpcyBhIHZhbGlkIGJpZ2ludCBwcmVmaXggKGBuYCBmb3IgXCJuZWdhdGl2ZVwiIGFuZCBgcGAgZm9yXG4gKiBcInBvc2l0aXZlXCIpLCBhbmQgY29weUFycmF5IGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBvbmUgZW5jb2RpbmdcbiAqIHByZWZpeGVzIGFycmF5cyB3aXRoIGBbYCB3aGlsZSB0aGUgb3RoZXIgdXNlcyBgXmAgKHdoaWNoIGlzIHByb2hpYml0ZWQgZnJvbVxuICogYXBwZWFyaW5nIGluIGFuIGVuY29kZWQgc3RyaW5nKS5cbiAqIFRoZSBvcmRlcmluZyBvZiB0aGVzZSBwcmVmaXhlcyBpcyB0aGUgc2FtZSBhcyB0aGUgcmFua09yZGVyaW5nIG9mIHRoZWlyXG4gKiByZXNwZWN0aXZlIFBhc3NTdHlsZXMsIGFuZCByYW5rT3JkZXIuanMgaW1wb3J0cyB0aGUgdGFibGUgZm9yIHRoaXMgcHVycG9zZS5cbiAqXG4gKiBJbiBhZGRpdGlvbiwgYHxgIGlzIHRoZSByZW1vdGFibGUtPm9yZGluYWwgbWFwcGluZyBwcmVmaXg6XG4gKiBUaGlzIGlzIG5vdCB1c2VkIGluIGNvdmVycyBidXQgaXQgaXNcbiAqIHJlc2VydmVkIGZyb20gdGhlIHNhbWUgc2V0IG9mIHN0cmluZ3MuIE5vdGUgdGhhdCB0aGUgcHJlZml4IGlzID4gYW55XG4gKiBwcmVmaXggdXNlZCBieSBhbnkgY292ZXIgc28gdGhhdCBvcmRpbmFsIG1hcHBpbmcga2V5cyBhcmUgYWx3YXlzIG91dHNpZGVcbiAqIHRoZSByYW5nZSBvZiB2YWxpZCBjb2xsZWN0aW9uIGVudHJ5IGtleXMuXG4gKi9cbmNvbnN0ICAgICAgICBwYXNzU3R5bGVQcmVmaXhlcz17XG5lcnJvcjonIScsXG5jb3B5UmVjb3JkOicoJyxcbnRhZ2dlZDonOicsXG5wcm9taXNlOic/JyxcbmNvcHlBcnJheTonW14nLFxuYm9vbGVhbjonYicsXG5udW1iZXI6J2YnLFxuYmlnaW50OiducCcsXG5yZW1vdGFibGU6J3InLFxuc3RyaW5nOidzJyxcbm51bGw6J3YnLFxuc3ltYm9sOid5Jyxcbi8qIEJlY2F1c2UgQXJyYXkucHJvdG90eXBlLnNvcnQgcHV0cyB1bmRlZmluZWQgdmFsdWVzIGF0IHRoZSBlbmQgd2l0aG91dCovXG4vKiBwYXNzaW5nIHRoZW0gdG8gYSBjb21wYXJpc29uIGZ1bmN0aW9uLCB1bmRlZmluZWQgTVVTVCBiZSB0aGUgbGFzdCovXG4vKiBjYXRlZ29yeS4qL1xudW5kZWZpbmVkOid6J307JGjNj19vbmNlLnBhc3NTdHlsZVByZWZpeGVzKHBhc3NTdHlsZVByZWZpeGVzKTtcblxuT2JqZWN0LnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVByZWZpeGVzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVByZWZpeGVzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlY29yZE5hbWVzIjpbInJlY29yZE5hbWVzIl0sInJlY29yZFZhbHVlcyI6WyJyZWNvcmRWYWx1ZXMiXSwiemVyb1BhZCI6WyJ6ZXJvUGFkIl0sIm1ha2VQYXNzYWJsZUtpdCI6WyJtYWtlUGFzc2FibGVLaXQiXSwibWFrZUVuY29kZVBhc3NhYmxlIjpbIm1ha2VFbmNvZGVQYXNzYWJsZSJdLCJtYWtlRGVjb2RlUGFzc2FibGUiOlsibWFrZURlY29kZVBhc3NhYmxlIl0sImlzRW5jb2RlZFJlbW90YWJsZSI6WyJpc0VuY29kZWRSZW1vdGFibGUiXSwicGFzc1N0eWxlUHJlZml4ZXMiOlsicGFzc1N0eWxlUHJlZml4ZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAMYqu5Eo6AABKOgAAKwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb0NhcERhdGEuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIlFDTEFTUyIsIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSIsIm1ha2VFbmNvZGVUb0NhcERhdGEiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxpc09iamVjdCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLFgsRmFpbCxxOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRozY9fYSA9PiAoaXNFcnJvckxpa2UgPSAkaM2PX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjNj19hID0+IChtYWtlVGFnZ2VkID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImdldFRhZ1wiLCBbJGjNj19hID0+IChnZXRUYWcgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaM2PX2EgPT4gKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzYWJsZSwgUmVtb3RhYmxlT2JqZWN0fSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuLyoqIEBpbXBvcnQge0VuY29kaW5nLCBFbmNvZGluZ1VuaW9ufSBmcm9tICcuL3R5cGVzLmpzJyAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsXG5kZWZpbmVQcm9wZXJ0aWVzLFxuaXMsXG5lbnRyaWVzLFxuZnJvbUVudHJpZXMsXG5mcmVlemV9PVxuT2JqZWN0O1xuXG4vKipcbiAqIFNwZWNpYWwgcHJvcGVydHkgbmFtZSB0aGF0IGluZGljYXRlcyBhbiBlbmNvZGluZyB0aGF0IG5lZWRzIHNwZWNpYWxcbiAqIGRlY29kaW5nLlxuICovXG5jb25zdCBRQ0xBU1M9J0BxY2xhc3MnOyRozY9fb25jZS5RQ0xBU1MoUUNMQVNTKTtcblxuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEByZXR1cm5zIHtlbmNvZGVkIGlzIEVuY29kaW5nVW5pb259XG4gKi9cbmNvbnN0IGhhc1FDbGFzcz0oZW5jb2RlZCk9Pmhhc093blByb3BlcnR5T2YoZW5jb2RlZCxRQ0xBU1MpO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7c3RyaW5nfSBxY2xhc3NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBxY2xhc3NNYXRjaGVzPShlbmNvZGVkLHFjbGFzcyk9PlxuaXNPYmplY3QoZW5jb2RlZCkmJlxuIWlzQXJyYXkoZW5jb2RlZCkmJlxuaGFzUUNsYXNzKGVuY29kZWQpJiZcbmVuY29kZWRbUUNMQVNTXT09PXFjbGFzcztcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVUb0NhcERhdGFPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGVPYmplY3QsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlRXJyb3JUb0NhcERhdGFdXG4gKi9cblxuY29uc3QgZG9udEVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT0ocmVtKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9tKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YDtcblxuY29uc3QgZG9udEVuY29kZUVycm9yVG9DYXBEYXRhPShlcnIpPT5GYWlsIGBlcnJvciBvYmplY3QgdW5leHBlY3RlZDogJHtlcnJ9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZVRvQ2FwRGF0YU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IEVuY29kaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVRvQ2FwRGF0YT0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhPWRvbnRFbmNvZGVSZW1vdGFibGVUb0NhcERhdGEsXG5lbmNvZGVQcm9taXNlVG9DYXBEYXRhPWRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhLFxuZW5jb2RlRXJyb3JUb0NhcERhdGE9ZG9udEVuY29kZUVycm9yVG9DYXBEYXRhfT1cbmVuY29kZU9wdGlvbnM7XG5cbi8qKlxuICogTXVzdCBlbmNvZGUgYHZhbGAgaW50byBwbGFpbiBKU09OIGRhdGEgKmNhbm9uaWNhbGx5Kiwgc3VjaCB0aGF0XG4gKiBgSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSkgPT09IEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpYC4gRm9yIG1vc3RcbiAqIGVuY29kaW5ncywgdGhlIG9yZGVyIG9mIHByb3BlcnRpZXMgb2YgZWFjaCBub2RlIG9mIHRoZSBvdXRwdXRcbiAqIHN0cnVjdHVyZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhbGdvcml0aG0gYmVsb3cgd2l0aG91dCBzcGVjaWFsXG4gKiBhcnJhbmdlbWVudCwgdXN1YWxseSBieSBiZWluZyBleHByZXNzZWQgZGlyZWN0bHkgYXMgYW4gb2JqZWN0IGxpdGVyYWwuXG4gKiBUaGUgZXhjZXB0aW9uIGlzIGNvcHlSZWNvcmRzLCB3aG9zZSBuYXR1cmFsIGVudW1lcmF0aW9uIG9yZGVyXG4gKiBjYW4gZGlmZmVyIGJldHdlZW4gY29weVJlY29yZHMgdGhhdCBvdXIgZGlzdHJpYnV0ZWQgb2JqZWN0IHNlbWFudGljc1xuICogY29uc2lkZXJzIHRvIGJlIGVxdWl2YWxlbnQuXG4gKiBTaW5jZSwgZm9yIGVhY2ggY29weVJlY29yZCwgd2Ugb25seSBhY2NlcHQgc3RyaW5nIHByb3BlcnR5IG5hbWVzLFxuICogbm90IHN5bWJvbHMsIHdlIGNhbiBjYW5vbmljYWxseSBzb3J0IHRoZSBuYW1lcyBmaXJzdC5cbiAqIEpTT04uc3RyaW5naWZ5IHdpbGwgdGhlbiB2aXNpdCB0aGVzZSBpbiB0aGF0IHNvcnRlZCBvcmRlci5cbiAqXG4gKiBFbmNvZGluZyB3aXRoIGEgY2Fub25pY2FsLUpTT04gZW5jb2RlciB3b3VsZCBhbHNvIHNvbHZlIHRoaXMgY2Fub25pY2FsbmVzc1xuICogcHJvYmxlbSBpbiBhIG1vcmUgbW9kdWxhciBhbmQgZW5jYXBzdWxhdGVkIG1hbm5lci4gTm90ZSB0aGF0IHRoZVxuICogYWN0dWFsIG9yZGVyIHByb2R1Y2VkIGhlcmUsIHRob3VnaCBpdCBhZ3JlZXMgd2l0aCBjYW5vbmljYWwtSlNPTiBvblxuICogY29weVJlY29yZCBwcm9wZXJ0eSBvcmRlcmluZywgZGlmZmVycyBmcm9tIGNhbm9uaWNhbC1KU09OIGFzIGEgd2hvbGVcbiAqIGluIHRoYXQgdGhlIG90aGVyIHJlY29yZCBwcm9wZXJ0aWVzIGFyZSB2aXNpdGVkIGluIHRoZSBvcmRlciBpbiB3aGljaFxuICogdGhleSBhcmUgbGl0ZXJhbGx5IHdyaXR0ZW4gYmVsb3cuIFRPRE8gcGVyaGFwcyB3ZSBzaG91bGQgaW5kZWVkIHN3aXRjaFxuICogdG8gYSBjYW5vbmljYWwgSlNPTiBlbmNvZGVyLCBhbmQgbm90IGRlbGljYXRlbHkgZGVwZW5kIG9uIHRoZSBvcmRlclxuICogaW4gd2hpY2ggdGhlc2Ugb2JqZWN0IGxpdGVyYWxzIGFyZSB3cml0dGVuLlxuICpcbiAqIFJlYWRlcnMgbXVzdCBub3QgY2FyZSBhYm91dCB0aGlzIG9yZGVyIGFueXdheS4gV2UgaW1wb3NlIHRoaXMgcmVxdWlyZW1lbnRcbiAqIG1haW5seSB0byByZWR1Y2Ugbm9uLWRldGVybWluaXNtIGV4cG9zZWQgb3V0c2lkZSBhIHZhdC5cbiAqXG4gKiBAcGFyYW0ge2FueX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHtFbmNvZGluZ30gZXhjZXB0IHRoYXQgYGVuY29kZVRvQ2FwRGF0YWAgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb0NhcERhdGFgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb0NhcERhdGFSZWN1cj0ocGFzc2FibGUpPT57XG4vKiBGaXJzdCB3ZSBoYW5kbGUgYWxsIHByaW1pdGl2ZXMuIFNvbWUgY2FuIGJlIHJlcHJlc2VudGVkIGRpcmVjdGx5IGFzKi9cbi8qIEpTT04sIGFuZCBzb21lIG11c3QgYmUgZW5jb2RlZCBhcyBbUUNMQVNTXSBjb21wb3NpdGVzLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybntbUUNMQVNTXTondW5kZWZpbmVkJ307XG4gfVxuY2FzZSdudW1iZXInOntcbi8qIFNwZWNpYWwtY2FzZSBudW1iZXJzIHdpdGggbm8gZGlnaXQtYmFzZWQgcmVwcmVzZW50YXRpb24uKi9cbmlmKE51bWJlci5pc05hTihwYXNzYWJsZSkpe1xucmV0dXJue1tRQ0xBU1NdOidOYU4nfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybntbUUNMQVNTXTonSW5maW5pdHknfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106Jy1JbmZpbml0eSd9O1xuIH1cbi8qIFBhc3MgdGhyb3VnaCBldmVyeXRoaW5nIGVsc2UsIHJlcGxhY2luZyAtMCB3aXRoIDAuKi9cbnJldHVybiBpcyhwYXNzYWJsZSwtMCk/MDpwYXNzYWJsZTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJue1xuW1FDTEFTU106J2JpZ2ludCcsXG5kaWdpdHM6U3RyaW5nKHBhc3NhYmxlKX07XG5cbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJue1xuW1FDTEFTU106J3N5bWJvbCcsXG5uYW1lfTtcblxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaGFzT3duUHJvcGVydHlPZihwYXNzYWJsZSxRQ0xBU1MpKXtcbi8qIEhpbGJlcnQgaG90ZWwqL1xuY29uc3R7W1FDTEFTU106cWNsYXNzVmFsdWUsLi4ucmVzdH09cGFzc2FibGU7XG4vKiogQHR5cGUge0VuY29kaW5nfSAqL1xuY29uc3QgcmVzdWx0PXtcbltRQ0xBU1NdOidoaWxiZXJ0Jyxcbm9yaWdpbmFsOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHFjbGFzc1ZhbHVlKX07XG5cbmlmKG93bktleXMocmVzdCkubGVuZ3RoPj0xKXtcbi8qIFdlIGhhcmRlbiB0aGUgZW50aXJlIGNhcERhdGEgZW5jb2RpbmcgYmVmb3JlIHdlIHJldHVybiBpdC4qL1xuLyogYGVuY29kZVRvQ2FwRGF0YWAgcmVxdWlyZXMgdGhhdCBpdHMgaW5wdXQgYmUgUGFzc2FibGUsIGFuZCovXG4vKiB0aGVyZWZvcmUgaGFyZGVuZWQuKi9cbi8qIFRoZSBgZnJlZXplYCBoZXJlIGlzIG5lZWRlZCBhbnl3YXksIGJlY2F1c2UgdGhlIGByZXN0YCBpcyovXG4vKiBmcmVzaGx5IGNvbnN0cnVjdGVkIGJ5IHRoZSBgLi4uYCBhYm92ZSwgYW5kIHdlJ3JlIHVzaW5nIGl0Ki9cbi8qIGFzIGltcHV0IGluIGFub3RoZXIgY2FsbCB0byBgZW5jb2RlVG9DYXBEYXRhYC4qL1xucmVzdWx0LnJlc3Q9ZW5jb2RlVG9DYXBEYXRhUmVjdXIoZnJlZXplKHJlc3QpKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEN1cnJlbnRseSBjb3B5UmVjb3JkIGFsbG93cyBvbmx5IHN0cmluZyBrZXlzIHNvIHRoaXMgd2lsbCovXG4vKiB3b3JrLiBJZiB3ZSBhbGxvdyBzb3J0YWJsZSBzeW1ib2wga2V5cywgdGhpcyB3aWxsIG5lZWQgdG8qL1xuLyogYmVjb21lIG1vcmUgaW50ZXJlc3RpbmcuKi9cbmNvbnN0IG5hbWVzPW93bktleXMocGFzc2FibGUpLnNvcnQoKTtcbnJldHVybiBmcm9tRW50cmllcyhcbm5hbWVzLm1hcCgobmFtZSk9PltuYW1lLGVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlW25hbWVdKV0pKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuW1FDTEFTU106J3RhZ2dlZCcsXG50YWc6Z2V0VGFnKHBhc3NhYmxlKSxcbnBheWxvYWQ6ZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhKFxucGFzc2FibGUsXG5lbmNvZGVUb0NhcERhdGFSZWN1cik7XG5cbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MpXG4gfSAke3EoJ3Nsb3QnKX06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgZW5jb2RlZD1lbmNvZGVQcm9taXNlVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTLFxuJ3Nsb3QnKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlRXJyb3JUb0NhcERhdGEocGFzc2FibGUsZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuaWYocWNsYXNzTWF0Y2hlcyhlbmNvZGVkLCdlcnJvcicpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidlcnJvcicpXG4gfTogJHtlbmNvZGVkfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYGludGVybmFsOiBVbnJlY29nbml6ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5jb25zdCBlbmNvZGVUb0NhcERhdGE9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gaGFyZGVuKGVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKSk7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZSkpO1xuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvQ2FwRGF0YShtYWtlRW5jb2RlVG9DYXBEYXRhKTtcbmhhcmRlbihtYWtlRW5jb2RlVG9DYXBEYXRhKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVQcm9taXNlRnJvbUNhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gRXJyb3J9IFtkZWNvZGVFcnJvckZyb21DYXBEYXRhXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0oc2xvdEVuY29kaW5nKT0+XG5GYWlsIGByZW1vdGFibGUgb3IgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Nsb3RFbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbUNhcERhdGE9KGVycm9yRW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyb3JFbmNvZGluZ31gO1xuXG4vKipcbiAqIFRoZSBjdXJyZW50IGVuY29kaW5nIGRvZXMgbm90IGdpdmUgdGhlIGRlY29kZXIgZW5vdWdoIGludG8gdG8gZGlzdGluZ3Vpc2hcbiAqIHdoZXRoZXIgYSBzbG90IHJlcHJlc2VudHMgYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLiBBcyBhbiBpbXBsZW1lbnRhdGlvblxuICogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmVcbiAqIHByb3ZpZGVkIGFuZCB0aGV5IG11c3QgYmUgdGhlIHNhbWUuXG4gKlxuICogVGhpcyBzZWVtcyBsaWtlIHRoZSBiZXN0IHN0YXJ0aW5nIHBvaW50IHRvIGluY3JlbWVudGFsbHkgZXZvbHZlIHRvIGFuXG4gKiBBUEkgd2hlcmUgdGhlc2UgY2FuIHJlbGlhYmx5IGRpZmZlci5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzRcbiAqXG4gKiBAcGFyYW0ge0RlY29kZU9wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBFbmNvZGluZykgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlRnJvbUNhcERhdGE9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPWRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YSxcbmRlY29kZVByb21pc2VGcm9tQ2FwRGF0YT1kb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVFcnJvckZyb21DYXBEYXRhPWRvbnREZWNvZGVFcnJvckZyb21DYXBEYXRhfT1cbmRlY29kZU9wdGlvbnM7XG5cbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPT09ZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhfHxcbkZhaWwgYEFuIGltcGxlbWVudGF0aW9uIHJlc3RyaWN0aW9uIGZvciBub3c6IElmIGVpdGhlciBkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSBvciBkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZSBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lOiAke3EoXG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSlcbiB9IHZzICR7cShkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEpfWA7XG5cbi8qKlxuICogYGRlY29kZUZyb21DYXBEYXRhYCBtYXkgcmVseSBvbiBganNvbkVuY29kZWRgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBqc29uRW5jb2RlZGBcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvQ2FwRGF0YWBcbiAqIGFib3ZlLCBpLmUuLCBgZGVjb2RlRnJvbUNhcERhdGFgIGNhbm5vdCByZWx5IG9uIGBqc29uRW5jb2RlZGAgYmVpbmcgYVxuICogdmFsaWQgbWFyc2hhbGxlZCByZXByZXNlbnRhdGlvbi4gUmF0aGVyLCBgZGVjb2RlRnJvbUNhcERhdGFgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30ganNvbkVuY29kZWQgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tQ2FwRGF0YT0oanNvbkVuY29kZWQpPT57XG5pZighaXNPYmplY3QoanNvbkVuY29kZWQpKXtcbi8qIHByaW1pdGl2ZXMgcGFzcyB0aHJvdWdoKi9cbnJldHVybiBqc29uRW5jb2RlZDtcbiB9XG5pZihpc0FycmF5KGpzb25FbmNvZGVkKSl7XG5yZXR1cm4ganNvbkVuY29kZWQubWFwKChlbmNvZGVkVmFsKT0+ZGVjb2RlRnJvbUNhcERhdGEoZW5jb2RlZFZhbCkpO1xuIH1lbHNlIGlmKGhhc1FDbGFzcyhqc29uRW5jb2RlZCkpe1xuY29uc3QgcWNsYXNzPWpzb25FbmNvZGVkW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCAke3EoUUNMQVNTKX0gdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuc3dpdGNoKHFjbGFzcyl7XG4vKiBFbmNvZGluZyBvZiBwcmltaXRpdmVzIG5vdCBoYW5kbGVkIGJ5IEpTT04qL1xuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdOYU4nOntcbnJldHVybiBOYU47XG4gfVxuY2FzZSdJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnLUluZmluaXR5Jzp7XG5yZXR1cm4tSW5maW5pdHk7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309anNvbkVuY29kZWQ7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuIEJpZ0ludChkaWdpdHMpO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBEZXByZWNhdGVkIHFjbGFzcy4gVE9ETyBtYWtlIGNvbmRpdGlvbmFsKi9cbi8qIG9uIGVudmlyb25tZW50IHZhcmlhYmxlLiBFdmVudHVhbGx5IHJlbW92ZSwgYnV0IGFmdGVyIGNvbmZpZGVudCovXG4vKiB0aGF0IHRoZXJlIGFyZSBubyBtb3JlIHN1cHBvcnRlZCBzZW5kZXJzLiovXG4vKiovXG5yZXR1cm4gU3ltYm9sLmFzeW5jSXRlcmF0b3I7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PWpzb25FbmNvZGVkO1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PWpzb25FbmNvZGVkO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLGRlY29kZUZyb21DYXBEYXRhKHBheWxvYWQpKTtcbiB9XG5jYXNlJ3Nsb3QnOntcbi8qIFNlZSBub3RlIGFib3ZlIGFib3V0IGhvdyB0aGUgY3VycmVudCBlbmNvZGluZyBjYW5ub3QgcmVsaWFibHkqL1xuLyogZGlzdGluZ3Vpc2ggd2hpY2ggd2Ugc2hvdWxkIGNhbGwsIHNvIGluIHRoZSBub24tZGVmYXVsdCBjYXNlKi9cbi8qIGJvdGggbXVzdCBiZSB0aGUgc2FtZSBhbmQgaXQgZG9lc24ndCBtYXR0ZXIgd2hpY2ggd2UgY2FsbC4qL1xuY29uc3QgZGVjb2RlZD1kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YShcbmpzb25FbmNvZGVkLFxuZGVjb2RlRnJvbUNhcERhdGEpO1xuXG4vKiBCRVdBUkU6IGNhcGRhdGEgZG9lcyBub3QgY2hlY2sgdGhhdCBgZGVjb2RlZGAgaXMqL1xuLyogYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLCBzaW5jZSB0aGF0IHdvdWxkIGJyZWFrIHNvbWUqL1xuLyogY2FwZGF0YSBjbGllbnRzLiBXZSBhcmUgZGVwcmVjYXRpbmcgY2FwZGF0YSwgYW5kIHRoZXNlIGNsaWVudHMqL1xuLyogd2lsbCBuZWVkIHRvIHVwZGF0ZSBiZWZvcmUgc3dpdGNoaW5nIHRvIHNtYWxsY2Fwcy4qL1xucmV0dXJuIGRlY29kZWQ7XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZGVjb2RlZD1kZWNvZGVFcnJvckZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbmlmKHBhc3NTdHlsZU9mKGRlY29kZWQpPT09J2Vycm9yJyl7XG5yZXR1cm4gZGVjb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YSBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7ZGVjb2RlZH1gO1xuIH1cbmNhc2UnaGlsYmVydCc6e1xuY29uc3R7b3JpZ2luYWwscmVzdH09anNvbkVuY29kZWQ7XG5oYXNPd25Qcm9wZXJ0eU9mKGpzb25FbmNvZGVkLCdvcmlnaW5hbCcpfHxcbkZhaWwgYEludmFsaWQgSGlsYmVydCBIb3RlbCBlbmNvZGluZyAke2pzb25FbmNvZGVkfWA7XG4vKiBEb24ndCBoYXJkZW4gc2luY2Ugd2UncmUgbm90IGRvbmUgbXV0YXRpbmcgaXQqL1xuY29uc3QgcmVzdWx0PXtbUUNMQVNTXTpkZWNvZGVGcm9tQ2FwRGF0YShvcmlnaW5hbCl9O1xuaWYoaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwncmVzdCcpKXtcbmNvbnN0IGlzTm9uRW1wdHlPYmplY3Q9XG50eXBlb2YgcmVzdD09PSdvYmplY3QnJiZcbnJlc3QhPT1udWxsJiZcbm93bktleXMocmVzdCkubGVuZ3RoPj0xO1xuaWYoIWlzTm9uRW1wdHlPYmplY3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyBtdXN0IGJlIGEgbm9uLWVtcHR5IG9iamVjdDogJHtyZXN0fWA7XG4gfVxuY29uc3QgcmVzdE9iaj1kZWNvZGVGcm9tQ2FwRGF0YShyZXN0KTtcbi8qIFRPRE8gcmVhbGx5IHNob3VsZCBhc3NlcnQgdGhhdCBgcGFzc1N0eWxlT2YocmVzdClgIGlzKi9cbi8qIGAnY29weVJlY29yZCdgIGJ1dCB3ZSdkIGhhdmUgdG8gaGFyZGVuIGl0IGFuZCBpdCBpcyB0b28qL1xuLyogZWFybHkgdG8gZG8gdGhhdC4qL1xuIWhhc093blByb3BlcnR5T2YocmVzdE9iaixRQ0xBU1MpfHxcbkZhaWwgYFJlc3QgbXVzdCBub3QgY29udGFpbiBpdHMgb3duIGRlZmluaXRpb24gb2YgJHtxKFFDTEFTUyl9YDtcbmRlZmluZVByb3BlcnRpZXMocmVzdWx0LGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocmVzdE9iaikpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBUaGlzIGlzIHRoZSBlcnJvciBjYXNlIHdlJ3JlIHRlc3RpbmcgZm9yKi9cbmNhc2UnaWJpZCc6e1xudGhyb3cgRmFpbCBgVGhlIGNhcERhdGEgcHJvdG9jb2wgbm8gbG9uZ2VyIHN1cHBvcnRzICR7cShRQ0xBU1MpfSAke3EoXG5xY2xhc3MpXG4gfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2V7XG5hc3NlcnQodHlwZW9mIGpzb25FbmNvZGVkPT09J29iamVjdCcmJmpzb25FbmNvZGVkIT09bnVsbCk7XG5jb25zdCBkZWNvZGVFbnRyeT0oW25hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5ICR7cShuYW1lKX0gb2YgJHtqc29uRW5jb2RlZH0gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoanNvbkVuY29kZWQpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVGcm9tQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZURlY29kZUZyb21DYXBEYXRhKG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJRQ0xBU1MiOlsiUUNMQVNTIl0sIm1ha2VFbmNvZGVUb0NhcERhdGEiOlsibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJtYWtlRGVjb2RlRnJvbUNhcERhdGEiOlsibWFrZURlY29kZUZyb21DYXBEYXRhIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIiwibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IHBhc3NTdHlsZU9mLGlzRXJyb3JMaWtlLG1ha2VUYWdnZWQsZ2V0VGFnLGhhc093blByb3BlcnR5T2YsYXNzZXJ0UGFzc2FibGVTeW1ib2wsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZSxYLEZhaWwscTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRozY9fYSA9PiAobWFrZVRhZ2dlZCA9ICRozY9fYSldXSxbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV0sW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc2FibGUsIFJlbW90YWJsZX0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZScgKi9cbi8qIEZJWE1FIGRlZmluZSBhY3R1YWwgdHlwZXMqL1xuLyoqIEB0eXBlZGVmIHthbnl9IFNtYWxsY2Fwc0VuY29kaW5nICovXG4vKiogQHR5cGVkZWYge2FueX0gU21hbGxjYXBzRW5jb2RpbmdVbmlvbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtpcyxlbnRyaWVzLGZyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0IEJBTkc9JyEnLmNoYXJDb2RlQXQoMCk7XG5jb25zdCBEQVNIPSctJy5jaGFyQ29kZUF0KDApO1xuXG4vKipcbiAqIEFuIGBlbmNvZGVUb1NtYWxsY2Fwc2AgZnVuY3Rpb24gdGFrZXMgYSBwYXNzYWJsZSBhbmQgcmV0dXJucyBhXG4gKiBKU09OLXJlcHJlc2VudGFibGUgb2JqZWN0IChpLmUuLCByb3VuZC10cmlwcGluZyBpdCB0aHJvdWdoXG4gKiBgSlNPTi5zdHJpbmdpZnlgIGFuZCBgSlNPTi5wYXJzZWAgd2l0aCBubyByZXBsYWNlcnMgb3IgcmV2aXZlcnNcbiAqIHJldHVybnMgYW4gZXF1aXZhbGVudCBzdHJ1Y3R1cmUgZXhjZXB0IGZvciBvYmplY3QgaWRlbnRpdHkpLlxuICogV2UgY2FsbCB0aGlzIHJlcHJlc2VudGF0aW9uIGEgU21hbGxjYXBzIEVuY29kaW5nLlxuICpcbiAqIEEgYGRlY29kZUZyb21TbWFsbGNhcHNgIGZ1bmN0aW9uIHRha2VzIGFzIGFyZ3VtZW50IHdoYXQgaXRcbiAqICphc3N1bWVzKiBpcyB0aGUgcmVzdWx0IG9mIGEgcGxhaW4gYEpTT04ucGFyc2VgIHdpdGggbm8gcmVzb2x2ZXIuIEl0IHRoZW5cbiAqIG11c3QgdmFsaWRhdGUgdGhhdCBpdCBpcyBhIHZhbGlkIFNtYWxsY2FwcyBFbmNvZGluZywgYW5kIGlmIGl0IGlzLFxuICogcmV0dXJuIGEgY29ycmVzcG9uZGluZyBwYXNzYWJsZS5cbiAqXG4gKiBTbWFsbGNhcHMgY29uc2lkZXJzIHRoZSBjaGFyYWN0ZXJzIGJldHdlZW4gYCFgIChhc2NpaSBjb2RlIDMzLCBCQU5HKVxuICogYW5kIGAtYCAoYXNjaWkgY29kZSA0NSwgREFTSCkgdG8gYmUgc3BlY2lhbCBwcmVmaXhlcyBhbGxvd2luZ1xuICogcmVwcmVzZW50YXRpb24gb2YgSlNPTi1pbmNvbXBhdGlibGUgZGF0YSB1c2luZyBzdHJpbmdzLlxuICogVGhlc2UgY2hhcmFjdGVycywgaW4gb3JkZXIsIGFyZSBgIVwiIyQlJicoKSorLC1gXG4gKiBPZiB0aGVzZSwgc21hbGxjYXBzIGN1cnJlbnRseSB1c2VzIHRoZSBmb2xsb3dpbmc6XG4gKlxuICogICogYCFgIC0gZXNjYXBlZCBzdHJpbmdcbiAqICAqIGArYCAtIG5vbi1uZWdhdGl2ZSBiaWdpbnRcbiAqICAqIGAtYCAtIG5lZ2F0aXZlIGJpZ2ludFxuICogICogYCNgIC0gbWFuaWZlc3QgY29uc3RhbnRcbiAqICAqIGAlYCAtIHN5bWJvbFxuICogICogYCRgIC0gcmVtb3RhYmxlXG4gKiAgKiBgJmAgLSBwcm9taXNlXG4gKlxuICogQWxsIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycyAoYFwiJygpKixgKSBhcmUgcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuXG4gKlxuICogVGhlIG1hbmlmZXN0IGNvbnN0YW50cyB0aGF0IHNtYWxsY2FwcyBjdXJyZW50bHkgdXNlcyBmb3IgdmFsdWVzOlxuICogICogYCN1bmRlZmluZWRgXG4gKiAgKiBgI05hTmBcbiAqICAqIGAjSW5maW5pdHlgXG4gKiAgKiBgIy1JbmZpbml0eWBcbiAqXG4gKiBhbmQgZm9yIHByb3BlcnR5IG5hbWVzIGFuYWxvZ291cyB0byBjYXBkYXRhIEBxY2xhc3M6XG4gKiAgKiBgI3RhZ2BcbiAqICAqIGAjZXJyb3JgXG4gKlxuICogQWxsIG90aGVyIGVuY29kZWQgc3RyaW5ncyBiZWdpbm5pbmcgd2l0aCBgI2AgYXJlIHJlc2VydmVkIGZvclxuICogZnV0dXJlIHVzZS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFN0clxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHN0YXJ0c1NwZWNpYWw9KGVuY29kZWRTdHIpPT57XG5pZihlbmNvZGVkU3RyPT09Jycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbi8qIGNoYXJDb2RlQXQoMCkgYW5kIG51bWJlciBjb21wYXJlIGlzIGEgYml0IGZhc3Rlci4qL1xuY29uc3QgY29kZT1lbmNvZGVkU3RyLmNoYXJDb2RlQXQoMCk7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgeW9kYSovXG5yZXR1cm4gQkFORzw9Y29kZSYmY29kZTw9REFTSDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZVRvU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIHJlbW90YWJsZTogUmVtb3RhYmxlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVFcnJvclRvU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz0ocmVtKT0+XG5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtyZW19YDtcblxuY29uc3QgZG9udEVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz0ocHJvbSk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwcm9tfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIpPT5cbkZhaWwgYGVycm9yIG9iamVjdCB1bmV4cGVjdGVkOiAke3EoZXJyKX1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlVG9TbWFsbGNhcHNPcHRpb25zfSBbZW5jb2RlT3B0aW9uc11cbiAqIGVuY29kZU9wdGlvbnMgaXMgYWN0dWFsbHkgb3B0aW9uYWwsIGJ1dCBub3QgbWFya2VkIGFzIHN1Y2ggdG8gd29yayBhcm91bmRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAyODZcbiAqXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW5jb2RlVG9TbWFsbGNhcHM9KGVuY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzPWRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyxcbmVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz1kb250RW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzLFxuZW5jb2RlRXJyb3JUb1NtYWxsY2Fwcz1kb250RW5jb2RlRXJyb3JUb1NtYWxsY2Fwc309XG5lbmNvZGVPcHRpb25zO1xuXG5jb25zdCBhc3NlcnRFbmNvZGVkRXJyb3I9KGVuY29kaW5nKT0+e1xudHlwZW9mIGVuY29kaW5nPT09J29iamVjdCcmJmhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyNlcnJvcicpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGhhdmUgXCIjZXJyb3JcIiBwcm9wZXJ0eTogJHtxKFxuZW5jb2RpbmcpXG4gfWA7XG4vKiBBc3NlcnQgdGhhdCB0aGUgI2Vycm9yIHByb3BlcnR5IGRlY29kZXMgdG8gYSBzdHJpbmcuKi9cbmNvbnN0IG1lc3NhZ2U9ZW5jb2RpbmdbJyNlcnJvciddO1xudHlwZW9mIG1lc3NhZ2U9PT0nc3RyaW5nJyYmKFxuIXN0YXJ0c1NwZWNpYWwobWVzc2FnZSl8fG1lc3NhZ2UuY2hhckF0KDApPT09JyEnKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBoYXZlIHN0cmluZyBtZXNzYWdlOiAke3EobWVzc2FnZSl9YDtcbiB9O1xuXG4vKipcbiAqIE11c3QgZW5jb2RlIGB2YWxgIGludG8gcGxhaW4gSlNPTiBkYXRhICpjYW5vbmljYWxseSosIHN1Y2ggdGhhdFxuICogYEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpID09PSBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKWAuIEZvciBtb3N0XG4gKiBlbmNvZGluZ3MsIHRoZSBvcmRlciBvZiBwcm9wZXJ0aWVzIG9mIGVhY2ggbm9kZSBvZiB0aGUgb3V0cHV0XG4gKiBzdHJ1Y3R1cmUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYWxnb3JpdGhtIGJlbG93IHdpdGhvdXQgc3BlY2lhbFxuICogYXJyYW5nZW1lbnQsIHVzdWFsbHkgYnkgYmVpbmcgZXhwcmVzc2VkIGRpcmVjdGx5IGFzIGFuIG9iamVjdCBsaXRlcmFsLlxuICogVGhlIGV4Y2VwdGlvbiBpcyBjb3B5UmVjb3Jkcywgd2hvc2UgbmF0dXJhbCBlbnVtZXJhdGlvbiBvcmRlclxuICogY2FuIGRpZmZlciBiZXR3ZWVuIGNvcHlSZWNvcmRzIHRoYXQgb3VyIGRpc3RyaWJ1dGVkIG9iamVjdCBzZW1hbnRpY3NcbiAqIGNvbnNpZGVycyB0byBiZSBlcXVpdmFsZW50LlxuICogU2luY2UsIGZvciBlYWNoIGNvcHlSZWNvcmQsIHdlIG9ubHkgYWNjZXB0IHN0cmluZyBwcm9wZXJ0eSBuYW1lcyxcbiAqIG5vdCBzeW1ib2xzLCB3ZSBjYW4gY2Fub25pY2FsbHkgc29ydCB0aGUgbmFtZXMgZmlyc3QuXG4gKiBKU09OLnN0cmluZ2lmeSB3aWxsIHRoZW4gdmlzaXQgdGhlc2UgaW4gdGhhdCBzb3J0ZWQgb3JkZXIuXG4gKlxuICogRW5jb2Rpbmcgd2l0aCBhIGNhbm9uaWNhbC1KU09OIGVuY29kZXIgd291bGQgYWxzbyBzb2x2ZSB0aGlzIGNhbm9uaWNhbG5lc3NcbiAqIHByb2JsZW0gaW4gYSBtb3JlIG1vZHVsYXIgYW5kIGVuY2Fwc3VsYXRlZCBtYW5uZXIuIE5vdGUgdGhhdCB0aGVcbiAqIGFjdHVhbCBvcmRlciBwcm9kdWNlZCBoZXJlLCB0aG91Z2ggaXQgYWdyZWVzIHdpdGggY2Fub25pY2FsLUpTT04gb25cbiAqIGNvcHlSZWNvcmQgcHJvcGVydHkgb3JkZXJpbmcsIGRpZmZlcnMgZnJvbSBjYW5vbmljYWwtSlNPTiBhcyBhIHdob2xlXG4gKiBpbiB0aGF0IHRoZSBvdGhlciByZWNvcmQgcHJvcGVydGllcyBhcmUgdmlzaXRlZCBpbiB0aGUgb3JkZXIgaW4gd2hpY2hcbiAqIHRoZXkgYXJlIGxpdGVyYWxseSB3cml0dGVuIGJlbG93LiBUT0RPIHBlcmhhcHMgd2Ugc2hvdWxkIGluZGVlZCBzd2l0Y2hcbiAqIHRvIGEgY2Fub25pY2FsIEpTT04gZW5jb2RlciwgYW5kIG5vdCBkZWxpY2F0ZWx5IGRlcGVuZCBvbiB0aGUgb3JkZXJcbiAqIGluIHdoaWNoIHRoZXNlIG9iamVjdCBsaXRlcmFscyBhcmUgd3JpdHRlbi5cbiAqXG4gKiBSZWFkZXJzIG11c3Qgbm90IGNhcmUgYWJvdXQgdGhpcyBvcmRlciBhbnl3YXkuIFdlIGltcG9zZSB0aGlzIHJlcXVpcmVtZW50XG4gKiBtYWlubHkgdG8gcmVkdWNlIG5vbi1kZXRlcm1pbmlzbSBleHBvc2VkIG91dHNpZGUgYSB2YXQuXG4gKlxuICogQHBhcmFtIHthbnl9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7U21hbGxjYXBzRW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb1NtYWxsY2Fwc2AgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb1NtYWxsY2Fwc2AgaXMgbm90XG4gKiBkaXJlY3RseSBleHBvc2VkLlxuICogV2hhdCdzIGV4cG9zZWQgaW5zdGVhZCBpcyBhIHdyYXBwZXIgdGhhdCBmcmVlemVzIHRoZSBvdXRwdXQgYmVmb3JlXG4gKiByZXR1cm5pbmcuIElmIHRoaXMgdHVybnMgb3V0IHRvIGltcGVkZSBzdGF0aWMgYW5hbHlzaXMgZm9yIGBoYXJkZW5gIHNhZmV0eSxcbiAqIHdlIGNhbiBhbHdheXMgcHV0IHRoZSAobm93IHJlZHVuZGFudCkgaGFyZGVucyBiYWNrIGluLiBUaGV5IGRvbid0IGh1cnQuXG4gKi9cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgaW50byBzbWFsbGNhcHMgc3RyaW5ncy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZihzdGFydHNTcGVjaWFsKHBhc3NhYmxlKSl7XG4vKiBTdHJpbmdzIHRoYXQgc3RhcnQgd2l0aCBhIHNwZWNpYWwgY2hhciBhcmUgcXVvdGVkIHdpdGggYCFgLiovXG4vKiBTaW5jZSBgIWAgaXMgaXRzZWxmIGEgc3BlY2lhbCBjaGFyYWN0ZXIsIHRoaXMgdHJpdmlhbGx5IGRvZXMqL1xuLyogdGhlIEhpbGJlcnQgaG90ZWwuIEFsc28sIHNpbmNlIHRoZSBzcGVjaWFsIGNoYXJhY3RlcnMgYXJlKi9cbi8qIGEgY29udGludW91cyBzdWJyYW5nZSBvZiBhc2NpaSwgdGhpcyBxdW90aW5nIGlzIHNvcnQtb3JkZXIqL1xuLyogcHJlc2VydmluZy4qL1xucmV0dXJuIGAhJHtwYXNzYWJsZX1gO1xuIH1cbi8qIEFsbCBvdGhlciBzdHJpbmdzIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJyN1bmRlZmluZWQnO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybicjTmFOJztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybicjSW5maW5pdHknO1xuIH1lbHNlIGlmKHBhc3NhYmxlPT09LUluZmluaXR5KXtcbnJldHVybicjLUluZmluaXR5JztcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0IHN0cj1TdHJpbmcocGFzc2FibGUpO1xucmV0dXJuICgvKiogQHR5cGUge2JpZ2ludH0gKi9wYXNzYWJsZTwwbj9zdHI6YCske3N0cn1gKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJuIGAlJHtuYW1lfWA7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKG5hbWUpLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm57XG4nI3RhZyc6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihnZXRUYWcocGFzc2FibGUpKSxcbnBheWxvYWQ6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZS5wYXlsb2FkKX07XG5cbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyQnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuLyogYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEJ1dCBsaW50ZXIgY29uZnVzZWQqL1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIkXCI6ICR7cmVzdWx0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyYnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJlwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvclRvU21hbGxjYXBzKHBhc3NhYmxlLGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuYXNzZXJ0RW5jb2RlZEVycm9yKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9TbWFsbGNhcHM9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5jb25zdCByZXN1bHQ9aGFyZGVuKFxuZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKSk7XG5cbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwcyk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvU21hbGxjYXBzKG1ha2VFbmNvZGVUb1NtYWxsY2Fwcyk7XG5oYXJkZW4obWFrZUVuY29kZVRvU21hbGxjYXBzKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVGcm9tU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBSZW1vdGFibGV9IFtkZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRFcnJvcjogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7cShlbmNvZGluZyl9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0RlY29kZUZyb21TbWFsbGNhcHNPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogU21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZUZyb21TbWFsbGNhcHM9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9ZG9udERlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9ZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwc309XG5kZWNvZGVPcHRpb25zO1xuXG4vKipcbiAqIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBtYXkgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBlbmNvZGluZ2BcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvU21hbGxjYXBzYFxuICogYWJvdmUsIGkuZS4sIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBjYW5ub3QgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIGFcbiAqIHZhbGlkIG1hcnNoYWxsZWQgcmVwcmVzZW50YXRpb24uIFJhdGhlciwgYGRlY29kZUZyb21TbWFsbGNhcHNgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtTbWFsbGNhcHNFbmNvZGluZ30gZW5jb2RpbmcgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PntcbnN3aXRjaCh0eXBlb2YgZW5jb2Rpbmcpe1xuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzp7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY2FzZSdzdHJpbmcnOntcbmlmKCFzdGFydHNTcGVjaWFsKGVuY29kaW5nKSl7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY29uc3QgYz1lbmNvZGluZy5jaGFyQXQoMCk7XG5zd2l0Y2goYyl7XG5jYXNlJyEnOntcbi8qIHVuLWhpbGJlcnQtaWZ5IHRoZSBzdHJpbmcqL1xucmV0dXJuIGVuY29kaW5nLnNsaWNlKDEpO1xuIH1cbmNhc2UnJSc6e1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShlbmNvZGluZy5zbGljZSgxKSk7XG4gfVxuY2FzZScjJzp7XG5zd2l0Y2goZW5jb2Rpbmcpe1xuY2FzZScjdW5kZWZpbmVkJzp7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNhc2UnI05hTic6e1xucmV0dXJuIE5hTjtcbiB9XG5jYXNlJyNJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnIy1JbmZpbml0eSc6e1xucmV0dXJuLUluZmluaXR5O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGB1bmtub3duIGNvbnN0YW50IFwiJHtxKGVuY29kaW5nKX1cImAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH1cbmNhc2UnKyc6XG5jYXNlJy0nOntcbnJldHVybiBCaWdJbnQoZW5jb2RpbmcpO1xuIH1cbmNhc2UnJCc6e1xuY29uc3QgcmVzdWx0PWRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG4vKiBAdHMtaWdub3JlIFhYWCBTbWFsbENhcHNFbmNvZGluZyovXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3JlbW90YWJsZScpe1xuRmFpbCBgaW50ZXJuYWw6IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGEgcmVtb3RhYmxlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuY2FzZScmJzp7XG5jb25zdCByZXN1bHQ9ZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3Byb21pc2UnKXtcbkZhaWwgYGludGVybmFsOiBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYSBwcm9taXNlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBTcGVjaWFsIGNoYXIgJHtxKFxuYylcbiB9IHJlc2VydmVkIGZvciBmdXR1cmUgdXNlOiAke2VuY29kaW5nfWA7XG4gfX1cblxuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihlbmNvZGluZz09PW51bGwpe1xucmV0dXJuIGVuY29kaW5nO1xuIH1cblxuaWYoaXNBcnJheShlbmNvZGluZykpe1xucmV0dXJuIGVuY29kaW5nLm1hcCgodmFsKT0+ZGVjb2RlRnJvbVNtYWxsY2Fwcyh2YWwpKTtcbiB9XG5cbmlmKGhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyN0YWcnKSl7XG5jb25zdHsnI3RhZyc6dGFnLHBheWxvYWQsLi4ucmVzdH09ZW5jb2Rpbmc7XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVmFsdWUgb2YgXCIjdGFnXCIsIHRoZSB0YWcsIG11c3QgYmUgYSBzdHJpbmc6ICR7ZW5jb2Rpbmd9YDtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGAjdGFnIHJlY29yZCB1bmV4cGVjdGVkIHByb3BlcnRpZXM6ICR7cShvd25LZXlzKHJlc3QpKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQoXG5kZWNvZGVGcm9tU21hbGxjYXBzKHRhZyksXG5kZWNvZGVGcm9tU21hbGxjYXBzKHBheWxvYWQpKTtcblxuIH1cblxuaWYoaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI2Vycm9yJykpe1xuY29uc3QgcmVzdWx0PWRlY29kZUVycm9yRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbnBhc3NTdHlsZU9mKHJlc3VsdCk9PT0nZXJyb3InfHxcbkZhaWwgYGludGVybmFsOiBkZWNvZGVFcnJvckZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGFuIGVycm9yOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5cbmNvbnN0IGRlY29kZUVudHJ5PShbZW5jb2RlZE5hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgZW5jb2RlZE5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbmVuY29kZWROYW1lKVxuIH0gb2YgJHtlbmNvZGluZ30gbXVzdCBiZSBhIHN0cmluZ2A7XG5lbmNvZGVkTmFtZS5jaGFyQXQoMCkhPT0nIyd8fFxuRmFpbCBgVW5yZWNvZ25pemVkIHJlY29yZCB0eXBlICR7cShlbmNvZGVkTmFtZSl9OiAke2VuY29kaW5nfWA7XG5jb25zdCBuYW1lPWRlY29kZUZyb21TbWFsbGNhcHMoZW5jb2RlZE5hbWUpO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBEZWNvZGVkIHByb3BlcnR5IG5hbWUgJHtuYW1lfSBmcm9tICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoZW5jb2RpbmcpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogdW5yZWNvZ25pemVkIEpTT04gdHlwZW9mICR7cShcbnR5cGVvZiBlbmNvZGluZylcbiB9OiAke2VuY29kaW5nfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZUZyb21TbWFsbGNhcHMpO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbmNvZGVUb1NtYWxsY2FwcyI6WyJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiXSwibWFrZURlY29kZUZyb21TbWFsbGNhcHMiOlsibWFrZURlY29kZUZyb21TbWFsbGNhcHMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAcE6fMmEsAABhLAAAKgAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc3siaW1wb3J0cyI6WyJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vZXJyb3JzIiwiLi9lbmNvZGVUb0NhcERhdGEuanMiXSwiZXhwb3J0cyI6WyJkZWNvZGVUb0p1c3RpbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBOYXQsZ2V0RXJyb3JDb25zdHJ1Y3Rvcixpc09iamVjdCxwYXNzYWJsZVN5bWJvbEZvck5hbWUscSxYLEZhaWwsUUNMQVNTOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7RW5jb2Rpbmd9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3N0cmluZ2lmeTpxdW90ZX09SlNPTjtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbmRlbnRlclxuICogQHByb3BlcnR5IHsob3BlbkJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBvcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gbGluZVxuICogQHByb3BlcnR5IHsodG9rZW46IHN0cmluZykgPT4gbnVtYmVyfSBuZXh0XG4gKiBAcHJvcGVydHkgeyhjbG9zZUJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBjbG9zZVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGRvbmVcbiAqL1xuXG4vKipcbiAqIEdlbmVyb3VzIHdoaXRlc3BhY2UgZm9yIHJlYWRhYmlsaXR5XG4gKlxuICogQHJldHVybnMge0luZGVudGVyfVxuICovXG5jb25zdCBtYWtlWWVzSW5kZW50ZXI9KCk9PntcbmNvbnN0IHN0cmluZ3M9W107XG5sZXQgbGV2ZWw9MDtcbmxldCBuZWVkU3BhY2U9ZmFsc2U7XG5jb25zdCBsaW5lPSgpPT57XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKCdcXG4nLCcgICcucmVwZWF0KGxldmVsKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT57XG5sZXZlbCs9MTtcbmlmKG5lZWRTcGFjZSl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKG9wZW5CcmFja2V0KTtcbiB9LFxubGluZSxcbm5leHQ6KHRva2VuKT0+e1xuaWYobmVlZFNwYWNlJiZ0b2tlbiE9PScsJyl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9dHJ1ZTtcbnJldHVybiBzdHJpbmdzLnB1c2godG9rZW4pO1xuIH0sXG5jbG9zZTooY2xvc2VCcmFja2V0KT0+e1xuYXNzZXJ0KGxldmVsPj0xKTtcbmxldmVsLT0xO1xubGluZSgpO1xucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT57XG5hc3NlcnQuZXF1YWwobGV2ZWwsMCk7XG5yZXR1cm4gc3RyaW5ncy5qb2luKCcnKTtcbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIElmIHRoZSBsYXN0IGNoYXJhY3RlciBvZiBvbmUgdG9rZW4gdG9nZXRoZXIgd2l0aCB0aGUgZmlyc3QgY2hhcmFjdGVyXG4gKiBvZiB0aGUgbmV4dCB0b2tlbiBtYXRjaGVzIHRoaXMgcGF0dGVybiwgdGhlbiB0aGUgdHdvIHRva2VucyBtdXN0IGJlXG4gKiBzZXBhcmF0ZWQgYnkgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZSB0aGVpciBtZWFuaW5nLiBPdGhlcndpc2UgdGhlXG4gKiB3aGl0ZXNwYWNlIGluIHVubmVjZXNzYXJ5LlxuICpcbiAqIFRoZSBgPCFgIGFuZCBgLT5gIGNhc2VzIHByZXZlbnQgdGhlIGFjY2lkZW50YWwgZm9ybWF0aW9uIG9mIGFuXG4gKiBodG1sLWxpa2UgY29tbWVudC4gSSBkb24ndCB0aGluayB0aGUgZG91YmxlIGFuZ2xlIGJyYWNrZXRzIGFyZSBhY3R1YWxseVxuICogbmVlZGVkIGJ1dCBJIGhhdmVuJ3QgdGhvdWdodCBhYm91dCBpdCBlbm91Z2ggdG8gcmVtb3ZlIHRoZW0uXG4gKi9cbmNvbnN0IGJhZFBhaXJQYXR0ZXJuPS9eKD86XFx3XFx3fDw8fD4+fFxcK1xcK3wtLXw8IXwtPikkLztcblxuLyoqXG4gKiBNaW5pbXVtIHdoaXRlc3BhY2UgbmVlZGVkIHRvIHByZXNldmUgbWVhbmluZy5cbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VOb0luZGVudGVyPSgpPT57XG4vKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuY29uc3Qgc3RyaW5ncz1bXTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT5zdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpLFxubGluZTooKT0+c3RyaW5ncy5sZW5ndGgsXG5uZXh0Oih0b2tlbik9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xKXtcbmNvbnN0IGxhc3Q9c3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzIC0tIGVycm9yKi9cbmlmKGxhc3QubGVuZ3RoPj0xJiZ0b2tlbi5sZW5ndGg+PTEpe1xuY29uc3QgcGFpcj0gYCR7bGFzdFtsYXN0Lmxlbmd0aC0xXX0ke3Rva2VuWzBdfWA7XG5pZihiYWRQYWlyUGF0dGVybi50ZXN0KHBhaXIpKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbiB9XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5pZihzdHJpbmdzLmxlbmd0aD49MSYmc3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXT09PScsJyl7XG5zdHJpbmdzLnBvcCgpO1xuIH1cbnJldHVybiBzdHJpbmdzLnB1c2goY2xvc2VCcmFja2V0KTtcbiB9LFxuZG9uZTooKT0+c3RyaW5ncy5qb2luKCcnKX0pO1xuXG4gfTtcblxuY29uc3QgaWRlbnRQYXR0ZXJuPS9eW2EtekEtWl1cXHcqJC87XG5oYXJkZW4oaWRlbnRQYXR0ZXJuKTtcbmNvbnN0IEF0QXRQcmVmaXhQYXR0ZXJuPS9eQEAoLiopJC87XG5oYXJkZW4oQXRBdFByZWZpeFBhdHRlcm4pO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kaW5nXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBzaG91bGRJbmRlbnRcbiAqIEBwYXJhbSB7YW55W119IFtzbG90c11cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGRlY29kZVRvSnVzdGluPShlbmNvZGluZyxzaG91bGRJbmRlbnQ9ZmFsc2Usc2xvdHM9W10pPT57XG4vKipcbiAqIFRoZSBmaXJzdCBwYXNzIGRvZXMgc29tZSBpbnB1dCB2YWxpZGF0aW9uLlxuICogSXRzIGNvbnRyb2wgZmxvdyBzaG91bGQgbWlycm9yIGByZWN1cmAgYXMgY2xvc2VseSBhcyBwb3NzaWJsZVxuICogYW5kIHRoZSB0d28gc2hvdWxkIGJlIG1haW50YWluZWQgdG9nZXRoZXIuIFRoZXkgbXVzdCB2aXNpdCBldmVyeXRoaW5nXG4gKiBpbiB0aGUgc2FtZSBvcmRlci5cbiAqXG4gKiBUT0RPIG5vdyB0aGF0IGliaWRzIGFyZSBnb25lLCB3ZSBzaG91bGQgZm9sZCB0aGlzIGJhY2sgdG9nZXRoZXIgaW50b1xuICogb25lIHZhbGlkYXRpbmcgcGFzcy5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgcHJlcGFyZT0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG5yZXR1cm47XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBxY2xhc3MgdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG5yZXR1cm47XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbnJldHVybjtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKHRhZywnc3RyaW5nJyk7XG5wcmVwYXJlKHBheWxvYWQpO1xucmV0dXJuO1xuIH1cbmNhc2Unc2xvdCc6e1xuY29uc3R7aW5kZXgsaWZhY2V9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbk5hdChpbmRleCk7XG5pZihpZmFjZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKGlmYWNlLCdzdHJpbmcnKTtcbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xuJ29yaWdpbmFsJ2luIHJhd1RyZWV8fFxuRmFpbCBgSW52YWxpZCBIaWxiZXJ0IEhvdGVsIGVuY29kaW5nICR7cmF3VHJlZX1gO1xucHJlcGFyZShvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmlmKHR5cGVvZiByZXN0IT09J29iamVjdCcpe1xudGhyb3cgRmFpbCBgUmVzdCAke3Jlc3R9IGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0YDtcbiB9XG5pZihyZXN0PT09bnVsbCl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgbnVsbGA7XG4gfVxuaWYoaXNBcnJheShyZXN0KSl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgYW4gYXJyYXlgO1xuIH1cbmlmKFFDTEFTUyBpbiByZXN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgJHtyZXN0fSBtdXN0IG5vdCBjb250YWluICR7cShRQ0xBU1MpfWA7XG4gfVxuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbnR5cGVvZiBuYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG5wcmVwYXJlKHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgbmFtZSl9YDtcbiB9XG5nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpIT09dW5kZWZpbmVkfHxcbkZhaWwgYE11c3QgYmUgdGhlIG5hbWUgb2YgYW4gRXJyb3IgY29uc3RydWN0b3IgJHtuYW1lfWA7XG50eXBlb2YgbWVzc2FnZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbWVzc2FnZSB0eXBlb2YgJHtxKHR5cGVvZiBtZXNzYWdlKX1gO1xucmV0dXJuO1xuIH1cblxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbnByZXBhcmUocmF3VHJlZVtpXSk7XG4gfVxuIH1lbHNle1xuY29uc3QgbmFtZXM9b3duS2V5cyhyYXdUcmVlKTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbmlmKHR5cGVvZiBuYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG4gfVxucHJlcGFyZShyYXdUcmVlW25hbWVdKTtcbiB9XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VJbmRlbnRlcj1zaG91bGRJbmRlbnQ/bWFrZVllc0luZGVudGVyOm1ha2VOb0luZGVudGVyO1xubGV0IG91dD1tYWtlSW5kZW50ZXIoKTtcblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBzZWNvbmQgcGFzcyByZWN1cnNpb24gYWZ0ZXIgdGhlIGZpcnN0IHBhc3MgYHByZXBhcmVgLlxuICogVGhlIGZpcnN0IHBhc3MgZGlkIHNvbWUgaW5wdXQgdmFsaWRhdGlvbiBzb1xuICogaGVyZSB3ZSBjYW4gc2FmZWx5IGFzc3VtZSBldmVyeXRoaW5nIHRob3NlIHRoaW5ncyBhcmUgdmFsaWRhdGVkLlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHtudW1iZXJ9XG4gKi9cbmNvbnN0IGRlY29kZT0ocmF3VHJlZSk9Pntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gcmVjdXIocmF3VHJlZSk7XG4gfTtcblxuY29uc3QgZGVjb2RlUHJvcGVydHk9KG5hbWUsdmFsdWUpPT57XG5vdXQubGluZSgpO1xuaWYobmFtZT09PSdfX3Byb3RvX18nKXtcbi8qIEphdmFTY3JpcHQgaW50ZXJwcmV0cyBge19fcHJvdG9fXzogeCwgLi4ufWAqL1xuLyogYXMgbWFraW5nIGFuIG9iamVjdCBpbmhlcml0aW5nIGZyb20gYHhgLCB3aGVyZWFzKi9cbi8qIGluIEpTT04gaXQgaXMgc2ltcGx5IGEgcHJvcGVydHkgbmFtZS4gUHJlc2VydmUgdGhlKi9cbi8qIEpTT04gbWVhbmluZy4qL1xub3V0Lm5leHQoIGBbXCJfX3Byb3RvX19cIl06YCk7XG4gfWVsc2UgaWYoaWRlbnRQYXR0ZXJuLnRlc3QobmFtZSkpe1xub3V0Lm5leHQoIGAke25hbWV9OmApO1xuIH1lbHNle1xub3V0Lm5leHQoIGAke3F1b3RlKG5hbWUpfTpgKTtcbiB9XG5kZWNvZGUodmFsdWUpO1xub3V0Lm5leHQoJywnKTtcbiB9O1xuXG4vKipcbiAqIE1vZGVsZWQgYWZ0ZXIgYGZ1bGxSZXZpdmVgIGluIG1hcnNoYWwuanNcbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCByZWN1cj0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG4vKiBwcmltaXRpdmVzIGdldCBxdW90ZWQqL1xucmV0dXJuIG91dC5uZXh0KHF1b3RlKHJhd1RyZWUpKTtcbiB9XG4vKiBBc3NlcnRpb25zIG9mIHRoZSBhYm92ZSB0byBuYXJyb3cgdGhlIHR5cGUuKi9cbmFzc2VydC50eXBlb2YocmF3VHJlZSwnb2JqZWN0Jyk7XG5hc3NlcnQocmF3VHJlZSE9PW51bGwpO1xuaWYoUUNMQVNTIGluIHJhd1RyZWUpe1xuY29uc3QgcWNsYXNzPXJhd1RyZWVbUUNMQVNTXTtcbmFzc2VydC50eXBlb2YocWNsYXNzLCdzdHJpbmcnKTtcbmFzc2VydCghaXNBcnJheShyYXdUcmVlKSk7XG4vKiBTd2l0Y2hpbmcgb24gYGVuY29kZWRbUUNMQVNTXWAgKG9yIGFueXRoaW5nIGxlc3MgZGlyZWN0LCBsaWtlKi9cbi8qIGBxY2xhc3NgKSBkb2VzIG5vdCBkaXNjcmltaW5hdGUgcmF3VHJlZSBpbiB0eXBlc2NyaXB0QDQuMi4zIGFuZCovXG4vKiBlYXJsaWVyLiovXG5zd2l0Y2gocmF3VHJlZVsnQHFjbGFzcyddKXtcbi8qIEVuY29kaW5nIG9mIHByaW1pdGl2ZXMgbm90IGhhbmRsZWQgYnkgSlNPTiovXG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ05hTic6XG5jYXNlJ0luZmluaXR5JzpcbmNhc2UnLUluZmluaXR5Jzp7XG4vKiBUaGVpciBxY2xhc3MgaXMgdGhlaXIgZXhwcmVzc2lvbiBzb3VyY2UuKi9cbnJldHVybiBvdXQubmV4dChxY2xhc3MpO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGRpZ2l0cywnc3RyaW5nJyk7XG5yZXR1cm4gb3V0Lm5leHQoIGAke0JpZ0ludChkaWdpdHMpfW5gKTtcbiB9XG5jYXNlJ0BAYXN5bmNJdGVyYXRvcic6e1xuLyogVE9ETyBkZXByZWNhdGVkLiBFdmVudHVhbGx5IHJlbW92ZS4qL1xucmV0dXJuIG91dC5uZXh0KCdTeW1ib2wuYXN5bmNJdGVyYXRvcicpO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5jb25zdHtuYW1lfT1yYXdUcmVlO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbmNvbnN0IHN5bT1wYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG5hc3NlcnQudHlwZW9mKHN5bSwnc3ltYm9sJyk7XG5jb25zdCByZWdpc3RlcmVkTmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihyZWdpc3RlcmVkTmFtZT09PXVuZGVmaW5lZCl7XG5jb25zdCBtYXRjaD1BdEF0UHJlZml4UGF0dGVybi5leGVjKG5hbWUpO1xuYXNzZXJ0KG1hdGNoIT09bnVsbCk7XG5jb25zdCBzdWZmaXg9bWF0Y2hbMV07XG5hc3NlcnQoU3ltYm9sW3N1ZmZpeF09PT1zeW0pO1xuYXNzZXJ0KGlkZW50UGF0dGVybi50ZXN0KHN1ZmZpeCkpO1xucmV0dXJuIG91dC5uZXh0KCBgU3ltYm9sLiR7c3VmZml4fWApO1xuIH1cbnJldHVybiBvdXQubmV4dCggYFN5bWJvbC5mb3IoJHtxdW90ZShyZWdpc3RlcmVkTmFtZSl9KWApO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdHt0YWcscGF5bG9hZH09cmF3VHJlZTtcbm91dC5uZXh0KCBgbWFrZVRhZ2dlZCgke3F1b3RlKHRhZyl9LGApO1xuZGVjb2RlKHBheWxvYWQpO1xucmV0dXJuIG91dC5uZXh0KCcpJyk7XG4gfVxuXG5jYXNlJ3Nsb3QnOntcbmxldHtpZmFjZX09cmF3VHJlZTtcbmNvbnN0IGluZGV4PU51bWJlcihOYXQocmF3VHJlZS5pbmRleCkpO1xuY29uc3QgbmVzdGVkUmVuZGVyPShhcmcpPT57XG5jb25zdCBvbGRPdXQ9b3V0O1xudHJ5e1xub3V0PW1ha2VOb0luZGVudGVyKCk7XG5kZWNvZGUoYXJnKTtcbnJldHVybiBvdXQuZG9uZSgpO1xuIH1maW5hbGx5e1xub3V0PW9sZE91dDtcbiB9XG4gfTtcbmlmKGluZGV4PHNsb3RzLmxlbmd0aCl7XG5jb25zdCBzbG90PW5lc3RlZFJlbmRlcihzbG90c1tpbmRleF0pO1xuaWYoaWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdFRvVmFsKCR7c2xvdH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3RUb1ZhbCgke3Nsb3R9LCR7aWZhY2V9KWApO1xuIH1lbHNlIGlmKGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0sJHtpZmFjZX0pYCk7XG4gfVxuXG5jYXNlJ2hpbGJlcnQnOntcbmNvbnN0e29yaWdpbmFsLHJlc3R9PXJhd1RyZWU7XG5vdXQub3BlbigneycpO1xuZGVjb2RlUHJvcGVydHkoUUNMQVNTLG9yaWdpbmFsKTtcbmlmKCdyZXN0J2luIHJhd1RyZWUpe1xuYXNzZXJ0LnR5cGVvZihyZXN0LCdvYmplY3QnKTtcbmFzc2VydChyZXN0IT09bnVsbCk7XG5jb25zdCBuYW1lcz1vd25LZXlzKHJlc3QpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbm5hbWUpXG4gfSBvZiAke3Jlc3R9IG11c3QgYmUgYSBzdHJpbmdgO1xuIH1cbmRlY29kZVByb3BlcnR5KG5hbWUscmVzdFtuYW1lXSk7XG4gfVxuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG5cbmNhc2UnZXJyb3InOntcbmNvbnN0e1xubmFtZSxcbm1lc3NhZ2UsXG5jYXVzZT11bmRlZmluZWQsXG5lcnJvcnM9dW5kZWZpbmVkfT1cbnJhd1RyZWU7XG5jYXVzZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBjYXVzZSBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbm5hbWUhPT0gYEFnZ3JlZ2F0ZUVycm9yYHx8XG5GYWlsIGBBZ2dyZWdhdGVFcnJvciBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbmVycm9ycz09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBlcnJvcnMgbm90IHlldCBpbXBsZW1lbnRlZCBpbiBtYXJzaGFsLWp1c3RpbmA7XG5yZXR1cm4gb3V0Lm5leHQoIGAke25hbWV9KCR7cXVvdGUobWVzc2FnZSl9KWApO1xuIH1cblxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgnW10nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCdbJyk7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbm91dC5saW5lKCk7XG5kZWNvZGUocmF3VHJlZVtpXSk7XG5vdXQubmV4dCgnLCcpO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ10nKTtcbiB9XG4gfWVsc2V7XG4vKiByYXdUcmVlIGlzIGFuIGBFbmNvZGluZ1JlY29yZGAgd2hpY2ggb25seSBoYXMgc3RyaW5nIGtleXMsKi9cbi8qIGJ1dCBzaW5jZSBvd25LZXlzIGlzIG5vdCBnZW5lcmljLCBpdCBjYW4ndCBwcm9wYWdhdGUgdGhhdCovXG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmF3VHJlZSk7XG5pZihuYW1lcy5sZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgne30nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCd7Jyk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJhd1RyZWVbbmFtZV0pO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG4gfVxuIH07XG5wcmVwYXJlKGVuY29kaW5nKTtcbmRlY29kZShlbmNvZGluZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9OyRozY9fb25jZS5kZWNvZGVUb0p1c3RpbihkZWNvZGVUb0p1c3Rpbik7XG5oYXJkZW4oZGVjb2RlVG9KdXN0aW4pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVjb2RlVG9KdXN0aW4iOlsiZGVjb2RlVG9KdXN0aW4iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL21hcnNoYWwuanMiXSwiZXhwb3J0cyI6WyJwYXJzZSIsInN0cmluZ2lmeSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLG1ha2VNYXJzaGFsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL21hcnNoYWwuanNcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaM2PX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEBpbXBvcnQge1Bhc3NhYmxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFZhbFRvU2xvdD0odmFsKT0+XG5GYWlsIGBNYXJzaGFsJ3Mgc3RyaW5naWZ5IHJlamVjdHMgcHJlc2VuY2VzIGFuZCBwcm9taXNlcyAke3ZhbH1gO1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFNsb3RUb1ZhbD0oc2xvdCxfaWZhY2UpPT5cbkZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3RzICR7c2xvdH1gO1xuXG5jb25zdCBiYWRBcnJheUhhbmRsZXI9aGFyZGVuKHtcbmdldDooX3RhcmdldCxuYW1lLF9yZWNlaXZlcik9PntcbmlmKG5hbWU9PT0nbGVuZ3RoJyl7XG5yZXR1cm4gMDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBNYXJzaGFsJ3MgcGFyc2UgbXVzdCBub3QgZW5jb2RlIGFueSBzbG90IHBvc2l0aW9ucyAke25hbWV9YDtcbiB9fSk7XG5cblxuY29uc3QgYmFkQXJyYXk9aGFyZGVuKG5ldyBQcm94eShoYXJkZW4oW10pLGJhZEFycmF5SGFuZGxlcikpO1xuXG5jb25zdHtzZXJpYWxpemUsdW5zZXJpYWxpemV9PW1ha2VNYXJzaGFsKFxuZG9Ob3RDb252ZXJ0VmFsVG9TbG90LFxuZG9Ob3RDb252ZXJ0U2xvdFRvVmFsLFxue1xuZXJyb3JUYWdnaW5nOidvZmYnLFxuLyogVE9ETyBmaXggdGVzdHMgdG8gd29ya3Mgd2l0aCBzbWFsbGNhcHMuKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J2NhcGRhdGEnfSk7XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3Qgc3RyaW5naWZ5PSh2YWwpPT5zZXJpYWxpemUodmFsKS5ib2R5OyRozY9fb25jZS5zdHJpbmdpZnkoc3RyaW5naWZ5KTtcbmhhcmRlbihzdHJpbmdpZnkpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJcbiAqIEByZXR1cm5zIHt1bmtub3dufVxuICovXG5jb25zdCBwYXJzZT0oc3RyKT0+XG51bnNlcmlhbGl6ZShcbmhhcmRlbih7XG5ib2R5OnN0cixcbnNsb3RzOmJhZEFycmF5fSkpOyRozY9fb25jZS5wYXJzZShwYXJzZSk7XG5cblxuaGFyZGVuKHBhcnNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0cmluZ2lmeSI6WyJzdHJpbmdpZnkiXSwicGFyc2UiOlsicGFyc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAE7Fc3pk3AACZNwAAIwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzeyJpbXBvcnRzIjpbIkBlbmRvL25hdCIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9lcnJvcnMiLCJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyIsIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9lbmNvZGVUb1NtYWxsY2Fwcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VNYXJzaGFsIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IE5hdCxhc3NlcnRQYXNzYWJsZSxnZXRJbnRlcmZhY2VPZixnZXRFcnJvckNvbnN0cnVjdG9yLGhhc093blByb3BlcnR5T2YsdG9QYXNzYWJsZUVycm9yLFgsRmFpbCxxLG1ha2VFcnJvcixhbm5vdGF0ZUVycm9yLG9iamVjdE1hcCxRQ0xBU1MsbWFrZUVuY29kZVRvQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbUNhcERhdGEsbWFrZURlY29kZUZyb21TbWFsbGNhcHMsbWFrZUVuY29kZVRvU21hbGxjYXBzOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaM2PX2EpXV0sW1wiZ2V0SW50ZXJmYWNlT2ZcIiwgWyRozY9fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJ0b1Bhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAodG9QYXNzYWJsZUVycm9yID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJtYWtlRXJyb3JcIiwgWyRozY9fYSA9PiAobWFrZUVycm9yID0gJGjNj19hKV1dLFtcImFubm90YXRlRXJyb3JcIiwgWyRozY9fYSA9PiAoYW5ub3RhdGVFcnJvciA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2NvbW1vbi9vYmplY3QtbWFwLmpzXCIsIFtbXCJvYmplY3RNYXBcIiwgWyRozY9fYSA9PiAob2JqZWN0TWFwID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV0sW1wibWFrZUVuY29kZVRvQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRW5jb2RlVG9DYXBEYXRhID0gJGjNj19hKV1dLFtcIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbUNhcERhdGEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVRvU21hbGxjYXBzLmpzXCIsIFtbXCJtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwc1wiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyA9ICRozY9fYSldXSxbXCJtYWtlRW5jb2RlVG9TbWFsbGNhcHNcIiwgWyRozY9fYSA9PiAobWFrZUVuY29kZVRvU21hbGxjYXBzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDb252ZXJ0U2xvdFRvVmFsLCBDb252ZXJ0VmFsVG9TbG90LCBGcm9tQ2FwRGF0YSwgTWFrZU1hcnNoYWxPcHRpb25zLCBUb0NhcERhdGF9IGZyb20gJy4vdHlwZXMuanMnO1xuICogQGltcG9ydCB7UGFzc2FibGUsIFBhc3NhYmxlQ2FwLCBSZW1vdGFibGVPYmplY3R9IGZyb20gJ0BlbmRvL3Bhc3Mtc3R5bGUnO1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlY30gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSc7XG4gKiBAaW1wb3J0IHtFbmNvZGluZ30gZnJvbSAnLi90eXBlcy5qcyc7XG4gKi9cblxuY29uc3R7ZGVmaW5lUHJvcGVydGllc309T2JqZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge0NvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRWYWxUb1Nsb3RGbj0oeCk9Png7XG4vKiogQHR5cGUge0NvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRTbG90VG9WYWxGbj0oeCxfKT0+eDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgU2xvdFxuICogQHBhcmFtIHtDb252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBbY29udmVydFZhbFRvU2xvdF1cbiAqIEBwYXJhbSB7Q29udmVydFNsb3RUb1ZhbDxTbG90Pn0gW2NvbnZlcnRTbG90VG9WYWxdXG4gKiBAcGFyYW0ge01ha2VNYXJzaGFsT3B0aW9uc30gb3B0aW9uc1xuICovXG5jb25zdCAgICAgICAgbWFrZU1hcnNoYWw9KFxuY29udmVydFZhbFRvU2xvdD1kZWZhdWx0VmFsVG9TbG90Rm4sXG5jb252ZXJ0U2xvdFRvVmFsPWRlZmF1bHRTbG90VG9WYWxGbixcbntcbmVycm9yVGFnZ2luZz0nb24nLFxubWFyc2hhbE5hbWU9J2Fub24tbWFyc2hhbCcsXG4vKiBUT0RPIFRlbXBvcmFyeSBoYWNrLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8yNzgwKi9cbmVycm9ySWROdW09MTAwMDAsXG4vKiBXZSBwcmVmZXIgdGhhdCB0aGUgY2FsbGVyIGluc3RlYWQgbG9nIHRvIHNvbWV3aGVyZSBoaWRkZW4qL1xuLyogdG8gYmUgcmV2ZWFsZWQgd2hlbiBjb3JyZWxhdGluZyB3aXRoIHRoZSByZWNlaXZlZCBlcnJvci4qL1xubWFyc2hhbFNhdmVFcnJvcj0oZXJyKT0+XG5jb25zb2xlLmxvZygnVGVtcG9yYXJ5IGxvZ2dpbmcgb2Ygc2VudCBlcnJvcicsZXJyKSxcbi8qIERlZmF1bHQgdG8gJ2NhcGRhdGEnIGJlY2F1c2UgaXQgd2FzIGltcGxlbWVudGVkIGZpcnN0LiovXG4vKiBTb21ldGltZXMsIG9udG9nZW55IGRvZXMgcmVjYXBpdHVsYXRlIHBoeWxvZ2VueSA7KSovXG5zZXJpYWxpemVCb2R5Rm9ybWF0PSdjYXBkYXRhJ309XG57fSk9Plxue1xuYXNzZXJ0LnR5cGVvZihtYXJzaGFsTmFtZSwnc3RyaW5nJyk7XG5lcnJvclRhZ2dpbmc9PT0nb24nfHxcbmVycm9yVGFnZ2luZz09PSdvZmYnfHxcbkZhaWwgYFRoZSBlcnJvclRhZ2dpbmcgb3B0aW9uIGNhbiBvbmx5IGJlIFwib25cIiBvciBcIm9mZlwiICR7ZXJyb3JUYWdnaW5nfWA7XG5jb25zdCBuZXh0RXJyb3JJZD0oKT0+e1xuZXJyb3JJZE51bSs9MTtcbnJldHVybiBgZXJyb3I6JHttYXJzaGFsTmFtZX0jJHtlcnJvcklkTnVtfWA7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7VG9DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCB0b0NhcERhdGE9KHJvb3QpPT57XG5jb25zdCBzbG90cz1bXTtcbi8qIG1hcHMgdmFsIChwcm9taXNlIG9yIHJlbW90YWJsZSkgdG8gaW5kZXggb2Ygc2xvdHNbXSovXG5jb25zdCBzbG90TWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHJldHVybnMge3tpbmRleDogbnVtYmVyLCByZXBlYXQ6IGJvb2xlYW59fVxuICovXG5jb25zdCBlbmNvZGVTbG90Q29tbW9uPShwYXNzYWJsZSk9PntcbmxldCBpbmRleD1zbG90TWFwLmdldChwYXNzYWJsZSk7XG5pZihpbmRleCE9PXVuZGVmaW5lZCl7XG4vKiBUT0RPIGFzc2VydCB0aGF0IGl0J3MgdGhlIHNhbWUgaWZhY2UgYXMgYmVmb3JlKi9cbmFzc2VydC50eXBlb2YoaW5kZXgsJ251bWJlcicpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OnRydWV9KTtcbiB9XG5cbmluZGV4PXNsb3RzLmxlbmd0aDtcbmNvbnN0IHNsb3Q9Y29udmVydFZhbFRvU2xvdChwYXNzYWJsZSk7XG5zbG90cy5wdXNoKHNsb3QpO1xuc2xvdE1hcC5zZXQocGFzc2FibGUsaW5kZXgpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OmZhbHNlfSk7XG4gfTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiB1bmtub3dufSBlbmNvZGVSZWN1clxuICogQHJldHVybnMge3tlcnJvcklkPzogc3RyaW5nLCBtZXNzYWdlOiBzdHJpbmcsIG5hbWU6IHN0cmluZ319XG4gKi9cbmNvbnN0IGVuY29kZUVycm9yQ29tbW9uPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBtZXNzYWdlPWVuY29kZVJlY3VyKCBgJHtlcnIubWVzc2FnZX1gKTtcbmFzc2VydC50eXBlb2YobWVzc2FnZSwnc3RyaW5nJyk7XG5jb25zdCBuYW1lPWVuY29kZVJlY3VyKCBgJHtlcnIubmFtZX1gKTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG4vKiBUT0RPIE11c3QgZW5jb2RlIGBjYXVzZWAsIGBlcnJvcnNgLCBidXQqL1xuLyogb25seSBvbmNlIGFsbCBwb3NzaWJsZSBjb3VudGVycGFydHkgZGVjb2RlcnMgYXJlIHRvbGVyYW50IG9mKi9cbi8qIHJlY2VpdmluZyB0aGVtLiovXG5pZihlcnJvclRhZ2dpbmc9PT0nb24nKXtcbi8qIFdlIGRlbGliZXJhdGVseSBkbyBub3Qgc2hhcmUgdGhlIHN0YWNrLCBidXQgaXQgd291bGQqL1xuLyogYmUgdXNlZnVsIHRvIGxvZyB0aGUgc3RhY2sgbG9jYWxseSBzbyBzb21lb25lIHdobyBoYXMqL1xuLyogcHJpdmlsZWdlZCBhY2Nlc3MgdG8gdGhlIHRocm93aW5nIFZhdCBjYW4gY29ycmVsYXRlKi9cbi8qIHRoZSBwcm9ibGVtIHdpdGggdGhlIHJlbW90ZSBWYXQgdGhhdCBnZXRzIHRoaXMqL1xuLyogc3VtbWFyeS4gSWYgd2UgZG8gdGhhdCwgd2UgY291bGQgYWxsb2NhdGUgc29tZSByYW5kb20qL1xuLyogaWRlbnRpZmllciBhbmQgaW5jbHVkZSBpdCBpbiB0aGUgbWVzc2FnZSwgdG8gaGVscCovXG4vKiB3aXRoIHRoZSBjb3JyZWxhdGlvbi4qL1xuY29uc3QgZXJyb3JJZD1lbmNvZGVSZWN1cihuZXh0RXJyb3JJZCgpKTtcbmFzc2VydC50eXBlb2YoZXJyb3JJZCwnc3RyaW5nJyk7XG5hbm5vdGF0ZUVycm9yKGVycixYIGBTZW50IGFzICR7ZXJyb3JJZH1gKTtcbm1hcnNoYWxTYXZlRXJyb3IoZXJyKTtcbnJldHVybiBoYXJkZW4oe2Vycm9ySWQsbWVzc2FnZSxuYW1lfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHttZXNzYWdlLG5hbWV9KTtcbiB9XG4gfTtcblxuaWYoc2VyaWFsaXplQm9keUZvcm1hdD09PSdjYXBkYXRhJyl7XG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVDYXB9IHBhc3NhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV1cbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlU2xvdFRvQ2FwRGF0YT0ocGFzc2FibGUsaWZhY2U9dW5kZWZpbmVkKT0+e1xuY29uc3R7aW5kZXgscmVwZWF0fT1lbmNvZGVTbG90Q29tbW9uKHBhc3NhYmxlKTtcblxuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J3Nsb3QnLGluZGV4fSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtbUUNMQVNTXTonc2xvdCcsaWZhY2UsaW5kZXh9KTtcbiB9XG4gfTtcblxuLyoqIEB0eXBlIHsocHJvbWlzZTogUmVtb3RhYmxlT2JqZWN0LCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHZhbCxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb0NhcERhdGEodmFsLGdldEludGVyZmFjZU9mKHZhbCkpO1xuXG4vKiogQHR5cGUgeyhwcm9taXNlOiBQcm9taXNlLCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9taXNlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YShwcm9taXNlKTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ30gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidlcnJvcicsLi4uZXJyRGF0YX0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvQ2FwRGF0YT1tYWtlRW5jb2RlVG9DYXBEYXRhKHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IGVuY29kZWQ9ZW5jb2RlVG9DYXBEYXRhKHJvb3QpO1xuY29uc3QgYm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuYm9keSxcbnNsb3RzfSk7XG5cbiB9ZWxzZSBpZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J3NtYWxsY2Fwcycpe1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcHJlZml4XG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9TbWFsbGNhcHM9KHByZWZpeCxwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG4vKiBUT0RPIGV4cGxvcmUgcmVtb3ZpbmcgdGhpcyBzcGVjaWFsIGNhc2UqL1xuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fWA7XG4gfVxucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fS4ke2lmYWNlfWA7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbW90YWJsZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJCcscmVtb3RhYmxlLGdldEludGVyZmFjZU9mKHJlbW90YWJsZSkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9TbWFsbGNhcHMoJyYnLHByb21pc2UpO1xuXG5jb25zdCBlbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBlcnJEYXRhPWVuY29kZUVycm9yQ29tbW9uKGVycixlbmNvZGVSZWN1cik7XG5jb25zdHttZXNzYWdlLC4uLnJlc3R9PWVyckRhdGE7XG5yZXR1cm4gaGFyZGVuKHsnI2Vycm9yJzptZXNzYWdlLC4uLnJlc3R9KTtcbiB9O1xuXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwcz1tYWtlRW5jb2RlVG9TbWFsbGNhcHMoe1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb1NtYWxsY2Fwcyhyb290KTtcbmNvbnN0IHNtYWxsY2Fwc0JvZHk9SlNPTi5zdHJpbmdpZnkoZW5jb2RlZCk7XG5yZXR1cm4gaGFyZGVuKHtcbi8qIFZhbGlkIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYSB2YWxpZCBzaWduYWwqL1xuLyogaW5kaWNhdGluZyBzbWFsbGNhcHMgZm9ybWF0LiovXG5ib2R5OiBgIyR7c21hbGxjYXBzQm9keX1gLFxuc2xvdHN9KTtcblxuIH1lbHNle1xuLyogVGhlIGB0aHJvd2AgaXMgYSBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEFkZGVkIGZvciBjb25mdXNlZCBsaW50ZXJzLiovXG50aHJvdyBGYWlsIGBVbnJlY29nbml6ZWQgc2VyaWFsaXplQm9keUZvcm1hdDogJHtxKHNlcmlhbGl6ZUJvZHlGb3JtYXQpfWA7XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VGdWxsUmV2aXZlPShzbG90cyk9Pntcbi8qKiBAdHlwZSB7TWFwPG51bWJlciwgUmVtb3RhYmxlT2JqZWN0IHwgUHJvbWlzZT59ICovXG5jb25zdCB2YWxNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7e2lmYWNlPzogc3RyaW5nLCBpbmRleDogbnVtYmVyfX0gc2xvdERhdGFcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5jb25zdCBkZWNvZGVTbG90Q29tbW9uPShzbG90RGF0YSk9PntcbmNvbnN0e2lmYWNlPXVuZGVmaW5lZCxpbmRleCwuLi5yZXN0fT1zbG90RGF0YTtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgc2xvdCBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuY29uc3QgZXh0YW50PXZhbE1hcC5nZXQoaW5kZXgpO1xuaWYoZXh0YW50KXtcbnJldHVybiBleHRhbnQ7XG4gfVxuLyogVE9ETyBTRUNVUklUWSBIQVpBUkQ6IG11c3QgZW5mb2NlIHRoYXQgcmVtb3RhYmxlIHZzIHByb21pc2UqL1xuLyogaXMgYWNjb3JkaW5nIHRvIHRoZSBlbmNvZGVkIHN0cmluZy4qL1xuY29uc3Qgc2xvdD1zbG90c1tOdW1iZXIoTmF0KGluZGV4KSldO1xuY29uc3QgdmFsPWNvbnZlcnRTbG90VG9WYWwoc2xvdCxpZmFjZSk7XG52YWxNYXAuc2V0KGluZGV4LHZhbCk7XG5yZXR1cm4gdmFsO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHt7XG4gKiAgIGVycm9ySWQ/OiBzdHJpbmcsXG4gKiAgIG1lc3NhZ2U6IHN0cmluZyxcbiAqICAgbmFtZTogc3RyaW5nLFxuICogICBjYXVzZTogdW5rbm93bixcbiAqICAgZXJyb3JzOiB1bmtub3duLFxuICogfX0gZXJyRGF0YVxuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IGRlY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0IGRlY29kZUVycm9yQ29tbW9uPShlcnJEYXRhLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7XG5lcnJvcklkPXVuZGVmaW5lZCxcbm1lc3NhZ2UsXG5uYW1lLFxuY2F1c2U9dW5kZWZpbmVkLFxuZXJyb3JzPXVuZGVmaW5lZCxcbi4uLnJlc3R9PVxuZXJyRGF0YTtcbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8yMDUyKi9cbi8qIGNhcERhdGEgZG9lcyBub3QgdHJhbnNmb3JtIHN0cmluZ3MuIFRoZSBpbW1lZGlhdGVseSBmb2xsb3dpbmcgY2FsbHMqL1xuLyogdG8gYGRlY29kZVJlY3VyYCBhcmUgZm9yIHJldXNlIGJ5IG90aGVyIGVuY29kaW5ncyB0aGF0IGRvLCovXG4vKiBzdWNoIGFzIHNtYWxsY2Fwcy4qL1xuY29uc3QgZE5hbWU9ZGVjb2RlUmVjdXIobmFtZSk7XG5jb25zdCBkTWVzc2FnZT1kZWNvZGVSZWN1cihtZXNzYWdlKTtcbi8qIGVycm9ySWQgaXMgYSBsYXRlIGFkZGl0aW9uIHNvIGJlIHRvbGVyYW50IG9mIGl0cyBhYnNlbmNlLiovXG5jb25zdCBkRXJyb3JJZD0vKiogQHR5cGUge3N0cmluZ30gKi9lcnJvcklkJiZkZWNvZGVSZWN1cihlcnJvcklkKTtcbmlmKHR5cGVvZiBkTmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBkTmFtZSl9YDtcbiB9XG5pZih0eXBlb2YgZE1lc3NhZ2UhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgZE1lc3NhZ2UpfWA7XG4gfVxuY29uc3QgZXJyQ29uc3RydWN0b3I9Z2V0RXJyb3JDb25zdHJ1Y3RvcihkTmFtZSl8fEVycm9yO1xuY29uc3QgZXJyb3JOYW1lPVxuZEVycm9ySWQ9PT11bmRlZmluZWQ/XG4gYFJlbW90ZSR7ZXJyQ29uc3RydWN0b3IubmFtZX1gOlxuIGBSZW1vdGUke2VyckNvbnN0cnVjdG9yLm5hbWV9KCR7ZEVycm9ySWR9KWA7XG5jb25zdCBvcHRpb25zPXtcbmVycm9yTmFtZSxcbnNhbml0aXplOmZhbHNlfTtcblxuaWYoY2F1c2Upe1xub3B0aW9ucy5jYXVzZT1kZWNvZGVSZWN1cihjYXVzZSk7XG4gfVxuaWYoZXJyb3JzKXtcbm9wdGlvbnMuZXJyb3JzPWRlY29kZVJlY3VyKGVycm9ycyk7XG4gfVxuY29uc3QgcmF3RXJyb3I9bWFrZUVycm9yKGRNZXNzYWdlLGVyckNvbnN0cnVjdG9yLG9wdGlvbnMpO1xuLyogTm90ZSB0aGF0IHRoaXMgZG9lcyBub3QgZGVjb2RlUmVjdXIgcmVzdCdzIHByb3BlcnR5IG5hbWVzLiovXG4vKiBUaGlzIHdvdWxkIGJlIGluY29uc2lzdGVudCB3aXRoIHNtYWxsY2FwcycgZXhwZWN0ZWQgaGFuZGxpbmcsKi9cbi8qIGJ1dCBpcyBmaW5lIGhlcmUgc2luY2UgaXQgaXMgb25seSB1c2VkIGZvciBgYW5ub3RhdGVFcnJvcmAsKi9cbi8qIHdoaWNoIGlzIGZvciBkaWFnbm9zdGljIGluZm8gdGhhdCBpcyBvdGhlcndpc2UgdW5vYnNlcnZhYmxlLiovXG5jb25zdCBkZXNjcz1vYmplY3RNYXAocmVzdCwoZGF0YSk9Pih7XG52YWx1ZTpkZWNvZGVSZWN1cihkYXRhKSxcbndyaXRhYmxlOmZhbHNlLFxuZW51bWVyYWJsZTpmYWxzZSxcbmNvbmZpZ3VyYWJsZTpmYWxzZX0pKTtcblxuZGVmaW5lUHJvcGVydGllcyhyYXdFcnJvcixkZXNjcyk7XG5oYXJkZW4ocmF3RXJyb3IpO1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcihyYXdFcnJvcik7XG4gfTtcblxuLyogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaCovXG4vKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb24qL1xuLyogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUqL1xuLyogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNCovXG5jb25zdCBkZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0ocmF3VHJlZSxfZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLnNsb3REYXRhfT1yYXdUcmVlO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oc2xvdERhdGEpO1xuIH07XG5cbmNvbnN0IGRlY29kZUVycm9yRnJvbUNhcERhdGE9KHJhd1RyZWUsZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLmVyckRhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlRXJyb3JDb21tb24oZXJyRGF0YSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbUNhcERhdGE9bWFrZURlY29kZUZyb21DYXBEYXRhKHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IG1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2Fwcz0ocHJlZml4KT0+e1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyaW5nRW5jb2RpbmdcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBfZGVjb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5yZXR1cm4oc3RyaW5nRW5jb2RpbmcsX2RlY29kZVJlY3VyKT0+e1xuYXNzZXJ0KHN0cmluZ0VuY29kaW5nLmNoYXJBdCgwKT09PXByZWZpeCk7XG4vKiBzbG90czogJHNsb3RJbmRleC5pZmFjZSBvciAkc2xvdEluZGV4Ki9cbmNvbnN0IGk9c3RyaW5nRW5jb2RpbmcuaW5kZXhPZignLicpO1xuY29uc3QgaW5kZXg9TnVtYmVyKHN0cmluZ0VuY29kaW5nLnNsaWNlKDEsaTwwP3VuZGVmaW5lZDppKSk7XG4vKiBpIDwgMCBtZWFucyB0aGVyZSB3YXMgbm8gaWZhY2UgaW5jbHVkZWQuKi9cbmNvbnN0IGlmYWNlPWk8MD91bmRlZmluZWQ6c3RyaW5nRW5jb2Rpbmcuc2xpY2UoaSsxKTtcbnJldHVybiBkZWNvZGVTbG90Q29tbW9uKHtpZmFjZSxpbmRleH0pO1xuIH07XG4gfTtcbmNvbnN0IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzKCckJyk7XG5jb25zdCBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyYnKTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyxkZWNvZGVSZWN1cik9PntcbmNvbnN0eycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdEVyckRhdGF9PWVuY29kaW5nO1xuIWhhc093blByb3BlcnR5T2YocmVzdEVyckRhdGEsJ21lc3NhZ2UnKXx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgZXJyb3IgcHJvcGVydHkgJHtxKCdtZXNzYWdlJyl9YDtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbih7bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX0sZGVjb2RlUmVjdXIpO1xuIH07XG5cbmNvbnN0IHJldml2ZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZUZyb21TbWFsbGNhcHMoe1xuLyogQHRzLWlnbm9yZSBYWFggU21hbGxDYXBzRW5jb2RpbmcqL1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcyxcbi8qIEB0cy1pZ25vcmUgWFhYIFNtYWxsQ2Fwc0VuY29kaW5nKi9cbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc30pO1xuIH07XG5cbi8qKlxuICogQHR5cGUge0Zyb21DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCBmcm9tQ2FwRGF0YT0oZGF0YSk9PntcbmNvbnN0e2JvZHksc2xvdHN9PWRhdGE7XG50eXBlb2YgYm9keT09PSdzdHJpbmcnfHxcbkZhaWwgYHVuc2VyaWFsaXplKCkgZ2l2ZW4gbm9uLWNhcGRhdGEgKC5ib2R5IGlzICR7Ym9keX0sIG5vdCBzdHJpbmcpYDtcbmlzQXJyYXkoZGF0YS5zbG90cyl8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLnNsb3RzIGFyZSBub3QgQXJyYXkpYDtcbmNvbnN0e3Jldml2ZUZyb21DYXBEYXRhLHJldml2ZUZyb21TbWFsbGNhcHN9PW1ha2VGdWxsUmV2aXZlKHNsb3RzKTtcbmxldCByZXN1bHQ7XG4vKiBKU09OIGNhbm5vdCBiZWdpbiB3aXRoIGEgJyMnLCBzbyB0aGlzIGlzIGFuIHVuYW1iaWd1b3VzIHNpZ25hbC4qL1xuaWYoYm9keS5jaGFyQXQoMCk9PT0nIycpe1xuY29uc3Qgc21hbGxjYXBzQm9keT1ib2R5LnNsaWNlKDEpO1xuY29uc3QgZW5jb2Rpbmc9aGFyZGVuKEpTT04ucGFyc2Uoc21hbGxjYXBzQm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tU21hbGxjYXBzKGVuY29kaW5nKSk7XG4gfWVsc2V7XG5jb25zdCByYXdUcmVlPWhhcmRlbihKU09OLnBhcnNlKGJvZHkpKTtcbnJlc3VsdD1oYXJkZW4ocmV2aXZlRnJvbUNhcERhdGEocmF3VHJlZSkpO1xuIH1cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzcqL1xuLyogd2hpY2ggc2hvdWxkIGJlIGNvbnNpZGVyZWQgZml4ZWQgb25jZSB3ZSd2ZSBjb21wbGV0ZWQgdGhlIHN3aXRjaCovXG4vKiB0byBzbWFsbGNhcHMuKi9cbmFzc2VydFBhc3NhYmxlKHJlc3VsdCk7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc2FibGVDYXB9ICovcmVzdWx0KTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtcbnRvQ2FwRGF0YSxcbmZyb21DYXBEYXRhLFxuXG4vKiBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkqL1xuLyoqIEBkZXByZWNhdGVkIHVzZSB0b0NhcERhdGEgKi9cbnNlcmlhbGl6ZTp0b0NhcERhdGEsXG4vKiogQGRlcHJlY2F0ZWQgdXNlIGZyb21DYXBEYXRhICovXG51bnNlcmlhbGl6ZTpmcm9tQ2FwRGF0YX0pO1xuXG4gfTskaM2PX29uY2UubWFrZU1hcnNoYWwobWFrZU1hcnNoYWwpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZU1hcnNoYWwiOlsibWFrZU1hcnNoYWwiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZrtByttBAADbQQAAJQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyIsIi4vZW5jb2RlUGFzc2FibGUuanMiXSwiZXhwb3J0cyI6WyJGdWxsUmFua0NvdmVyIiwiYXNzZXJ0UmFua1NvcnRlZCIsImNvbXBhcmF0b3JNaXJyb3JJbWFnZSIsImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVSYW5rIiwiY292ZXJlZEVudHJpZXMiLCJnZXRJbmRleENvdmVyIiwiZ2V0UGFzc1N0eWxlQ292ZXIiLCJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaXNSYW5rU29ydGVkIiwibWFrZUNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsInNvcnRCeVJhbmsiLCJ0cml2aWFsQ29tcGFyYXRvciIsInVuaW9uUmFua0NvdmVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBnZXRUYWcscGFzc1N0eWxlT2YsbmFtZUZvclBhc3NhYmxlU3ltYm9sLEZhaWwscSxwYXNzU3R5bGVQcmVmaXhlcyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVBhc3NhYmxlLmpzXCIsIFtbXCJwYXNzU3R5bGVQcmVmaXhlc1wiLCBbJGjNj19hID0+IChwYXNzU3R5bGVQcmVmaXhlcyA9ICRozY9fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjNj19hID0+IChyZWNvcmROYW1lcyA9ICRozY9fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRozY9fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUGFzc1N0eWxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJ1xuICogQGltcG9ydCB7RnVsbENvbXBhcmUsIFBhcnRpYWxDb21wYXJlLCBQYXJ0aWFsQ29tcGFyaXNvbiwgUmFua0NvbXBhcmUsIFJhbmtDb3Zlcn0gZnJvbSAnLi90eXBlcy5qcydcbiAqL1xuXG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLHNldFByb3RvdHlwZU9mLGlzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmFua0NvbXBhcmF0b3JLaXRcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGFudGlDb21wYXJhdG9yXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGdWxsQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtbbnVtYmVyLCBudW1iZXJdfSBJbmRleENvdmVyXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBlcXVhbGl0eSBjb21wYXJpc29uIHVzZWQgYnkgSmF2YVNjcmlwdCdzIE1hcCBhbmQgU2V0XG4gKiBhYnN0cmFjdGlvbnMsIHdoZXJlIE5hTiBpcyB0aGUgc2FtZSBhcyBOYU4gYW5kIC0wIGlzIHRoZSBzYW1lIGFzXG4gKiAwLiBNYXJzaGFsIHNlcmlhbGl6ZXMgLTAgYXMgemVybywgc28gdGhlIHNlbWFudGljcyBvZiBvdXIgZGlzdHJpYnV0ZWRcbiAqIG9iamVjdCBzeXN0ZW0gZG9lcyBub3QgZGlzdGluZ3Vpc2ggMCBmcm9tIC0wLlxuICpcbiAqIGBzYW1lVmFsdWVaZXJvYCBpcyB0aGUgRWNtYVNjcmlwdCBzcGVjIG5hbWUgZm9yIHRoaXMgZXF1YWxpdHkgY29tcGFyaXNvbixcbiAqIGJ1dCBUT0RPIHdlIG5lZWQgYSBiZXR0ZXIgbmFtZSBmb3IgdGhlIEFQSS5cbiAqXG4gKiBAcGFyYW0ge2FueX0geFxuICogQHBhcmFtIHthbnl9IHlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzYW1lVmFsdWVaZXJvPSh4LHkpPT54PT09eXx8aXMoeCx5KTtcblxuY29uc3QgICAgICAgIHRyaXZpYWxDb21wYXJhdG9yPShsZWZ0LHJpZ2h0KT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnksIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMqL1xubGVmdDxyaWdodD8tMTpsZWZ0PT09cmlnaHQ/MDoxO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8UGFzc1N0eWxlLCB7IGluZGV4OiBudW1iZXIsIGNvdmVyOiBSYW5rQ292ZXIgfT59IFBhc3NTdHlsZVJhbmtzUmVjb3JkXG4gKi8kaM2PX29uY2UudHJpdmlhbENvbXBhcmF0b3IodHJpdmlhbENvbXBhcmF0b3IpO1xuXG5jb25zdCBwYXNzU3R5bGVSYW5rcz0vKiogQHR5cGUge1Bhc3NTdHlsZVJhbmtzUmVjb3JkfSAqL1xuZnJvbUVudHJpZXMoXG5lbnRyaWVzKHBhc3NTdHlsZVByZWZpeGVzKVxuLyogU29ydCBlbnRyaWVzIGJ5IGFzY2VuZGluZyBwcmVmaXguKi8uXG5zb3J0KChbX2xlZnRTdHlsZSxsZWZ0UHJlZml4ZXNdLFtfcmlnaHRTdHlsZSxyaWdodFByZWZpeGVzXSk9PntcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihsZWZ0UHJlZml4ZXMscmlnaHRQcmVmaXhlcyk7XG4gfSkuXG5tYXAoKFtwYXNzU3R5bGUscHJlZml4ZXNdLGluZGV4KT0+e1xuLyogQ292ZXIgYWxsIHN0cmluZ3MgdGhhdCBzdGFydCB3aXRoIGFueSBjaGFyYWN0ZXIgaW4gYHByZWZpeGVzYCwqL1xuLyogdmVyaWZ5aW5nIHRoYXQgaXQgaXMgc29ydGVkIHNvIHRoYXQgaXMqL1xuLyogYWxsIHMgc3VjaCB0aGF0IHByZWZpeGVzLmF0KDApIOKJpCBzIDwgc3VjY2Vzc29yKHByZWZpeGVzLmF0KC0xKSkuKi9cbnByZWZpeGVzPT09Wy4uLnByZWZpeGVzXS5zb3J0KCkuam9pbignJyl8fFxuRmFpbCBgdW5zb3J0ZWQgcHJlZml4ZXMgZm9yIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7cShwcmVmaXhlcyl9YDtcbmNvbnN0IGNvdmVyPVtcbnByZWZpeGVzLmNoYXJBdCgwKSxcblN0cmluZy5mcm9tQ2hhckNvZGUocHJlZml4ZXMuY2hhckNvZGVBdChwcmVmaXhlcy5sZW5ndGgtMSkrMSldO1xuXG5yZXR1cm5bcGFzc1N0eWxlLHtpbmRleCxjb3Zlcn1dO1xuIH0pKTtcblxuXG5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVSYW5rcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVSYW5rcyk7XG5cbi8qKlxuICogQXNzb2NpYXRlIHdpdGggZWFjaCBwYXNzU3R5bGUgYSBSYW5rQ292ZXIgdGhhdCBtYXkgYmUgYW4gb3ZlcmVzdGltYXRlLFxuICogYW5kIHdob3NlIHJlc3VsdHMgdGhlcmVmb3JlIG5lZWQgdG8gYmUgZmlsdGVyZWQgZG93bi4gRm9yIGV4YW1wbGUsIGJlY2F1c2VcbiAqIHRoZXJlIGlzIG5vdCBhIHNtYWxsZXN0IG9yIGJpZ2dlc3QgYmlnaW50LCBib3VuZCBpdCBieSBgTmFOYCAodGhlIGxhc3QgcGxhY2VcbiAqIG51bWJlcikgYW5kIGAnJ2AgKHRoZSBlbXB0eSBzdHJpbmcsIHdoaWNoIGlzIHRoZSBmaXJzdCBwbGFjZSBzdHJpbmcpLiBUaHVzLFxuICogYSByYW5nZSBxdWVyeSB1c2luZyB0aGlzIHJhbmdlIG1heSBpbmNsdWRlIHRoZXNlIHZhbHVlcywgd2hpY2ggd291bGQgdGhlblxuICogbmVlZCB0byBiZSBmaWx0ZXJlZCBvdXQuXG4gKlxuICogQHBhcmFtIHtQYXNzU3R5bGV9IHBhc3NTdHlsZVxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldFBhc3NTdHlsZUNvdmVyPShwYXNzU3R5bGUpPT5wYXNzU3R5bGVSYW5rc1twYXNzU3R5bGVdLmNvdmVyOyRozY9fb25jZS5nZXRQYXNzU3R5bGVDb3ZlcihnZXRQYXNzU3R5bGVDb3Zlcik7XG5oYXJkZW4oZ2V0UGFzc1N0eWxlQ292ZXIpO1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPFJhbmtDb21wYXJlLFdlYWtTZXQ8UGFzc2FibGVbXT4+fVxuICovXG5jb25zdCBtZW1vT2ZTb3J0ZWQ9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxSYW5rQ29tcGFyZT59XG4gKi9cbmNvbnN0IGNvbXBhcmF0b3JNaXJyb3JJbWFnZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhcnRpYWxDb21wYXJlfSBbY29tcGFyZVJlbW90YWJsZXNdXG4gKiBBIGNvbXBhcmF0b3IgZm9yIGFzc2lnbmluZyBhbiBpbnRlcm5hbCBvcmRlciB0byByZW1vdGFibGVzLlxuICogSXQgZGVmYXVsdHMgdG8gYSBmdW5jdGlvbiB0aGF0IGFsd2F5cyByZXR1cm5zIGBOYU5gLCBtZWFuaW5nIHRoYXQgYWxsXG4gKiByZW1vdGFibGVzIGFyZSBpbmNvbXBhcmFibGUgYW5kIHNob3VsZCB0aWUgZm9yIHRoZSBzYW1lIHJhbmsgYnlcbiAqIHNob3J0LWNpcmN1aXRpbmcgd2l0aG91dCBmdXJ0aGVyIHJlZmluZW1lbnQgKGUuZy4sIG5vdCBvbmx5IGFyZSBgcjFgIGFuZCBgcjJgXG4gKiB0aWVkLCBidXQgc28gYXJlIGBbcjEsIDBdYCBhbmQgYFtyMiwgXCJ4XCJdYCkuXG4gKiBAcmV0dXJucyB7UmFua0NvbXBhcmF0b3JLaXR9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29tcGFyYXRvcktpdD0oY29tcGFyZVJlbW90YWJsZXM9KF94LF95KT0+TmFOKT0+e1xuLyoqIEB0eXBlIHtQYXJ0aWFsQ29tcGFyZX0gKi9cbmNvbnN0IGNvbXBhcmF0b3I9KGxlZnQscmlnaHQpPT57XG5pZihzYW1lVmFsdWVaZXJvKGxlZnQscmlnaHQpKXtcbnJldHVybiAwO1xuIH1cbmNvbnN0IGxlZnRTdHlsZT1wYXNzU3R5bGVPZihsZWZ0KTtcbmNvbnN0IHJpZ2h0U3R5bGU9cGFzc1N0eWxlT2YocmlnaHQpO1xuaWYobGVmdFN0eWxlIT09cmlnaHRTdHlsZSl7XG5yZXR1cm4gdHJpdmlhbENvbXBhcmF0b3IoXG5wYXNzU3R5bGVSYW5rc1tsZWZ0U3R5bGVdLmluZGV4LFxucGFzc1N0eWxlUmFua3NbcmlnaHRTdHlsZV0uaW5kZXgpO1xuXG4gfVxuLyogZXNsaW50LWRpc2FibGUgQGVuZG8vcmVzdHJpY3QtY29tcGFyaXNvbi1vcGVyYW5kcyAtLVxuICogV2Uga25vdyBgbGVmdGAgYW5kIGByaWdodGAgYXJlIGNvbXBhcmFibGUuXG4gKi9cbnN3aXRjaChsZWZ0U3R5bGUpe1xuY2FzZSdyZW1vdGFibGUnOntcbnJldHVybiBjb21wYXJlUmVtb3RhYmxlcyhsZWZ0LHJpZ2h0KTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ251bGwnOlxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbi8qIEZvciBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIGFsbCBtZW1iZXJzIG9mIHRoYXQgcGFzc1N0eWxlIGFyZSB0aWVkKi9cbi8qIGZvciB0aGUgc2FtZSByYW5rLiovXG5yZXR1cm4gMDtcbiB9XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOntcbi8qIFdpdGhpbiBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIHRoZSByYW5rIG9yZGVyaW5nIGFncmVlcyB3aXRoKi9cbi8qIEphdmFTY3JpcHQncyByZWxhdGlvbmFsIG9wZXJhdG9ycyBgPGAgYW5kIGA+YC4qL1xuaWYobGVmdDxyaWdodCl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbmFzc2VydChsZWZ0PnJpZ2h0KTtcbnJldHVybiAxO1xuIH1cbiB9XG5jYXNlJ3N5bWJvbCc6e1xucmV0dXJuIGNvbXBhcmF0b3IoXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wobGVmdCksXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wocmlnaHQpKTtcblxuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBgTmFOYCdzIHJhbmsgaXMgYWZ0ZXIgYWxsIG90aGVyIG51bWJlcnMuKi9cbmlmKE51bWJlci5pc05hTihsZWZ0KSl7XG5hc3NlcnQoIU51bWJlci5pc05hTihyaWdodCkpO1xucmV0dXJuIDE7XG4gfWVsc2UgaWYoTnVtYmVyLmlzTmFOKHJpZ2h0KSl7XG5yZXR1cm4tMTtcbiB9XG4vKiBUaGUgcmFuayBvcmRlcmluZyBvZiBub24tTmFOIG51bWJlcnMgYWdyZWVzIHdpdGggSmF2YVNjcmlwdCdzKi9cbi8qIHJlbGF0aW9uYWwgb3BlcmF0b3JzICc8JyBhbmQgJz4nLiovXG5pZihsZWZ0PHJpZ2h0KXtcbnJldHVybi0xO1xuIH1lbHNle1xuYXNzZXJ0KGxlZnQ+cmlnaHQpO1xucmV0dXJuIDE7XG4gfVxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBpbnZlcnNlIHNvcnRlZCBvcmRlciBvZiBwcm9wZXJ0eSBuYW1lcywgdGhlbiovXG4vKiBsZXhpY29ncmFwaGljIGJ5IGNvcnJlc3BvbmRpbmcgdmFsdWVzIGluIHRoYXQgc2FtZSBpbnZlcnNlKi9cbi8qIG9yZGVyIG9mIHRoZWlyIHByb3BlcnR5IG5hbWVzLiBDb21wYXJpbmcgbmFtZXMgYnkgdGhlbXNlbHZlcyBmaXJzdCwqL1xuLyogYWxsIHJlY29yZHMgd2l0aCB0aGUgZXhhY3Qgc2FtZSBzZXQgb2YgcHJvcGVydHkgbmFtZXMgc29ydCBuZXh0IHRvKi9cbi8qIGVhY2ggb3RoZXIgaW4gYSByYW5rLXNvcnQgb2YgY29weVJlY29yZHMuKi9cblxuLyogVGhlIGNvcHlSZWNvcmQgaW52YXJpYW50cyBlbmZvcmNlZCBieSBwYXNzU3R5bGVPZiBlbnN1cmUgdGhhdCovXG4vKiBhbGwgdGhlIHByb3BlcnR5IG5hbWVzIGFyZSBzdHJpbmdzLiBXZSBuZWVkIHRoZSByZXZlcnNlIHNvcnRlZCBvcmRlciovXG4vKiBvZiB0aGVzZSBuYW1lcywgd2hpY2ggd2UgdGhlbiBjb21wYXJlIGxleGljb2dyYXBoaWNhbGx5LiBUaGlzIGVuc3VyZXMqL1xuLyogdGhhdCBpZiB0aGUgbmFtZXMgb2YgcmVjb3JkIFggYXJlIGEgc3Vic2V0IG9mIHRoZSBuYW1lcyBvZiByZWNvcmQgWSwqL1xuLyogdGhlbiByZWNvcmQgWCB3aWxsIGhhdmUgYW4gZWFybGllciByYW5rIGFuZCBzb3J0IHRvIHRoZSBsZWZ0IG9mIFkuKi9cbmNvbnN0IGxlZnROYW1lcz1yZWNvcmROYW1lcyhsZWZ0KTtcbmNvbnN0IHJpZ2h0TmFtZXM9cmVjb3JkTmFtZXMocmlnaHQpO1xuXG5jb25zdCByZXN1bHQ9Y29tcGFyYXRvcihsZWZ0TmFtZXMscmlnaHROYW1lcyk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuY29uc3QgbGVmdFZhbHVlcz1yZWNvcmRWYWx1ZXMobGVmdCxsZWZ0TmFtZXMpO1xuY29uc3QgcmlnaHRWYWx1ZXM9cmVjb3JkVmFsdWVzKHJpZ2h0LHJpZ2h0TmFtZXMpO1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdFZhbHVlcyxyaWdodFZhbHVlcyk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMqL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnRbaV0scmlnaHRbaV0pO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG4vKiBJZiBhbGwgbWF0Y2hpbmcgZWxlbWVudHMgd2VyZSB0aWVkLCB0aGVuIGFjY29yZGluZyB0byB0aGVpciBsZW5ndGhzLiovXG4vKiBJZiBhcnJheSBYIGlzIGEgcHJlZml4IG9mIGFycmF5IFksIHRoZW4gWCBoYXMgYW4gZWFybGllciByYW5rIHRoYW4gWS4qL1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBgW1N5bWJvbC50b1N0cmluZ1RhZ11gIHRoZW4gYC5wYXlsb2FkYC4qL1xuY29uc3QgbGFiZWxDb21wPWNvbXBhcmF0b3IoZ2V0VGFnKGxlZnQpLGdldFRhZyhyaWdodCkpO1xuaWYobGFiZWxDb21wIT09MCl7XG5yZXR1cm4gbGFiZWxDb21wO1xuIH1cbnJldHVybiBjb21wYXJhdG9yKGxlZnQucGF5bG9hZCxyaWdodC5wYXlsb2FkKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBwYXNzU3R5bGU6ICR7cShsZWZ0U3R5bGUpfWA7XG4gfX1cblxuLyogZXNsaW50LWVuYWJsZSAqL1xuIH07XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBvdXRlckNvbXBhcmF0b3I9KHgseSk9PlxuLyogV2hlbiB0aGUgaW5uZXIgY29tcGFyYXRvciByZXR1cm5zIE5hTiB0byBpbmRpY2F0ZSBpbmNvbXBhcmFiaWxpdHksKi9cbi8qIHJlcGxhY2UgdGhhdCB3aXRoIDAgdG8gaW5kaWNhdGUgYSB0aWUuKi9cbi8qKiBAdHlwZSB7RXhjbHVkZTxQYXJ0aWFsQ29tcGFyaXNvbiwgTmFOPn0gKi9jb21wYXJhdG9yKHgseSl8fDA7XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBhbnRpQ29tcGFyYXRvcj0oeCx5KT0+b3V0ZXJDb21wYXJhdG9yKHkseCk7XG5cbm1lbW9PZlNvcnRlZC5zZXQob3V0ZXJDb21wYXJhdG9yLG5ldyBXZWFrU2V0KCkpO1xubWVtb09mU29ydGVkLnNldChhbnRpQ29tcGFyYXRvcixuZXcgV2Vha1NldCgpKTtcbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuc2V0KG91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcik7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChhbnRpQ29tcGFyYXRvcixvdXRlckNvbXBhcmF0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtjb21wYXJhdG9yOm91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcn0pO1xuIH07XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEByZXR1cm5zIHtSYW5rQ29tcGFyZT19XG4gKi8kaM2PX29uY2UubWFrZUNvbXBhcmF0b3JLaXQobWFrZUNvbXBhcmF0b3JLaXQpO1xuY29uc3QgICAgICAgIGNvbXBhcmF0b3JNaXJyb3JJbWFnZT0oY29tcGFyYXRvcik9PlxuY29tcGFyYXRvck1pcnJvckltYWdlcy5nZXQoY29tcGFyYXRvcik7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjNj19vbmNlLmNvbXBhcmF0b3JNaXJyb3JJbWFnZShjb21wYXJhdG9yTWlycm9ySW1hZ2UpO1xuY29uc3QgICAgICAgIGlzUmFua1NvcnRlZD0ocGFzc2FibGVzLGNvbXBhcmUpPT57XG5jb25zdCBzdWJNZW1vT2ZTb3J0ZWQ9bWVtb09mU29ydGVkLmdldChjb21wYXJlKTtcbmFzc2VydChzdWJNZW1vT2ZTb3J0ZWQhPT11bmRlZmluZWQpO1xuaWYoc3ViTWVtb09mU29ydGVkLmhhcyhwYXNzYWJsZXMpKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydChwYXNzU3R5bGVPZihwYXNzYWJsZXMpPT09J2NvcHlBcnJheScpO1xuZm9yKGxldCBpPTE7aTxwYXNzYWJsZXMubGVuZ3RoO2krPTEpe1xuaWYoY29tcGFyZShwYXNzYWJsZXNbaS0xXSxwYXNzYWJsZXNbaV0pPj0xKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuc3ViTWVtb09mU29ydGVkLmFkZChwYXNzYWJsZXMpO1xucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNSYW5rU29ydGVkKGlzUmFua1NvcnRlZCk7XG5oYXJkZW4oaXNSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UmFua1NvcnRlZD0oc29ydGVkLGNvbXBhcmUpPT5cbmlzUmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSl8fFxuLyogVE9ETyBhc3NlcnQgb24gYnVnIGNvdWxkIGxlYWQgdG8gaW5maW5pdGUgcmVjdXJzaW9uLiBGaXguKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5GYWlsIGBNdXN0IGJlIHJhbmsgc29ydGVkOiAke3NvcnRlZH0gdnMgJHtzb3J0QnlSYW5rKHNvcnRlZCxjb21wYXJlKX1gOyRozY9fb25jZS5hc3NlcnRSYW5rU29ydGVkKGFzc2VydFJhbmtTb3J0ZWQpO1xuaGFyZGVuKGFzc2VydFJhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHBhc3NhYmxlc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHNvcnRCeVJhbms9KHBhc3NhYmxlcyxjb21wYXJlKT0+e1xuaWYoQXJyYXkuaXNBcnJheShwYXNzYWJsZXMpKXtcbmhhcmRlbihwYXNzYWJsZXMpO1xuLyogQ2FsbGluZyBpc1JhbmtTb3J0ZWQgZ2l2ZXMgaXQgYSBjaGFuY2UgdG8gZ2V0IG1lbW9pemVkIGZvciovXG4vKiB0aGlzIGBjb21wYXJlYCBmdW5jdGlvbiBldmVuIGlmIGl0IHdhcyBhbHJlYWR5IG1lbW9pemVkIGZvciBhIGRpZmZlcmVudCovXG4vKiBgY29tcGFyZWAgZnVuY3Rpb24uKi9cbmlmKGlzUmFua1NvcnRlZChwYXNzYWJsZXMsY29tcGFyZSkpe1xucmV0dXJuIHBhc3NhYmxlcztcbiB9XG4gfVxuY29uc3QgdW5zb3J0ZWQ9Wy4uLnBhc3NhYmxlc107XG51bnNvcnRlZC5mb3JFYWNoKGhhcmRlbik7XG5jb25zdCBzb3J0ZWQ9dW5zb3J0ZWQuc29ydChjb21wYXJlKTtcbi8qIEZvciByZXZlcnNlIGNvbXBhcmlzb24sIG1vdmUgYHVuZGVmaW5lZGAgdmFsdWVzIGZyb20gdGhlIGVuZCB0byB0aGUgc3RhcnQuKi9cbi8qIE5vdGUgdGhhdCBwYXNzU3R5bGVQcmVmaXhlcyAoQHNlZSB7QGxpbmsgLi9lbmNvZGVQYXNzYWJsZS5qc30pIE1VU1QgTk9UKi9cbi8qIHNvcnQgYW55IGNhdGVnb3J5IGFmdGVyIGB1bmRlZmluZWRgLiovXG5pZihjb21wYXJlKHRydWUsdW5kZWZpbmVkKT4wKXtcbmxldCBpPXNvcnRlZC5sZW5ndGgtMTtcbndoaWxlKGk+PTAmJnNvcnRlZFtpXT09PXVuZGVmaW5lZClpLT0xO1xuY29uc3Qgbj1zb3J0ZWQubGVuZ3RoLWktMTtcbmlmKG4+MCYmbjxzb3J0ZWQubGVuZ3RoKXtcbnNvcnRlZC5jb3B5V2l0aGluKG4sMCk7XG5zb3J0ZWQuZmlsbCgvKiogQHR5cGUge1R9ICovdW5kZWZpbmVkLDAsbik7XG4gfVxuIH1cbmhhcmRlbihzb3J0ZWQpO1xuY29uc3Qgc3ViTWVtb09mU29ydGVkPW1lbW9PZlNvcnRlZC5nZXQoY29tcGFyZSk7XG5hc3NlcnQoc3ViTWVtb09mU29ydGVkIT09dW5kZWZpbmVkKTtcbnN1Yk1lbW9PZlNvcnRlZC5hZGQoc29ydGVkKTtcbnJldHVybiBzb3J0ZWQ7XG4gfTskaM2PX29uY2Uuc29ydEJ5UmFuayhzb3J0QnlSYW5rKTtcbmhhcmRlbihzb3J0QnlSYW5rKTtcblxuLyoqXG4gKiBTZWVcbiAqIGh0dHBzOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0JpbmFyeV9zZWFyY2hfYWxnb3JpdGhtI1Byb2NlZHVyZV9mb3JfZmluZGluZ190aGVfbGVmdG1vc3RfZWxlbWVudFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBrZXlcbiAqIEBwYXJhbSB7KFwibGVmdE1vc3RcIiB8IFwicmlnaHRNb3N0XCIpPX0gYmlhc1xuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmFua1NlYXJjaD0oc29ydGVkLGNvbXBhcmUsa2V5LGJpYXM9J2xlZnRNb3N0Jyk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xubGV0IGxlZnQ9MDtcbmxldCByaWdodD1zb3J0ZWQubGVuZ3RoO1xud2hpbGUobGVmdDxyaWdodCl7XG5jb25zdCBtPU1hdGguZmxvb3IoKGxlZnQrcmlnaHQpLzIpO1xuY29uc3QgY29tcD1jb21wYXJlKHNvcnRlZFttXSxrZXkpO1xuaWYoY29tcDw9LTF8fGNvbXA9PT0wJiZiaWFzPT09J3JpZ2h0TW9zdCcpe1xubGVmdD1tKzE7XG4gfWVsc2V7XG5hc3NlcnQoY29tcD49MXx8Y29tcD09PTAmJmJpYXM9PT0nbGVmdE1vc3QnKTtcbnJpZ2h0PW07XG4gfVxuIH1cbnJldHVybiBiaWFzPT09J2xlZnRNb3N0Jz9sZWZ0OnJpZ2h0LTE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IHJhbmtDb3ZlclxuICogQHJldHVybnMge0luZGV4Q292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbmRleENvdmVyPShzb3J0ZWQsY29tcGFyZSxbbGVmdEtleSxyaWdodEtleV0pPT57XG5hc3NlcnRSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKTtcbmNvbnN0IGxlZnRJbmRleD1yYW5rU2VhcmNoKHNvcnRlZCxjb21wYXJlLGxlZnRLZXksJ2xlZnRNb3N0Jyk7XG5jb25zdCByaWdodEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUscmlnaHRLZXksJ3JpZ2h0TW9zdCcpO1xucmV0dXJuW2xlZnRJbmRleCxyaWdodEluZGV4XTtcbiB9OyRozY9fb25jZS5nZXRJbmRleENvdmVyKGdldEluZGV4Q292ZXIpO1xuaGFyZGVuKGdldEluZGV4Q292ZXIpO1xuXG4vKiogQHR5cGUge1JhbmtDb3Zlcn0gKi9cbmNvbnN0ICAgICAgICBGdWxsUmFua0NvdmVyPWhhcmRlbihbJycsJ3snXSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7SW5kZXhDb3Zlcn0gaW5kZXhDb3ZlclxuICogQHJldHVybnMge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59XG4gKi8kaM2PX29uY2UuRnVsbFJhbmtDb3ZlcihGdWxsUmFua0NvdmVyKTtcbmNvbnN0ICAgICAgICBjb3ZlcmVkRW50cmllcz0oc29ydGVkLFtsZWZ0SW5kZXgscmlnaHRJbmRleF0pPT57XG4vKiogQHR5cGUge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59ICovXG5jb25zdCBpdGVyYWJsZT1oYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmxldCBpPWxlZnRJbmRleDtcbnJldHVybiBoYXJkZW4oe1xubmV4dDooKT0+e1xuaWYoaTw9cmlnaHRJbmRleCl7XG5jb25zdCBlbGVtZW50PXNvcnRlZFtpXTtcbmkrPTE7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTpbaSxlbGVtZW50XSxkb25lOmZhbHNlfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTp1bmRlZmluZWQsZG9uZTp0cnVlfSk7XG4gfVxuIH19KTtcblxuIH19KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjNj19vbmNlLmNvdmVyZWRFbnRyaWVzKGNvdmVyZWRFbnRyaWVzKTtcbmhhcmRlbihjb3ZlcmVkRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtYXhSYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKT49MD9hOmI7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtaW5SYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKTw9MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgdW5pb25SYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCB1bmlvblJhbmtDb3ZlclBhaXI9KFtsZWZ0QSxyaWdodEFdLFtsZWZ0QixyaWdodEJdKT0+W1xubWluUmFuayhjb21wYXJlLGxlZnRBLGxlZnRCKSxcbm1heFJhbmsoY29tcGFyZSxyaWdodEEscmlnaHRCKV07XG5cbnJldHVybiBjb3ZlcnMucmVkdWNlKHVuaW9uUmFua0NvdmVyUGFpcixbJ3snLCcnXSk7XG4gfTskaM2PX29uY2UudW5pb25SYW5rQ292ZXJzKHVuaW9uUmFua0NvdmVycyk7XG5oYXJkZW4odW5pb25SYW5rQ292ZXJzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpbnRlcnNlY3RSYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCBpbnRlcnNlY3RSYW5rQ292ZXJQYWlyPShbbGVmdEEscmlnaHRBXSxbbGVmdEIscmlnaHRCXSk9Pltcbm1heFJhbmsoY29tcGFyZSxsZWZ0QSxsZWZ0QiksXG5taW5SYW5rKGNvbXBhcmUscmlnaHRBLHJpZ2h0QildO1xuXG5yZXR1cm4gY292ZXJzLnJlZHVjZShpbnRlcnNlY3RSYW5rQ292ZXJQYWlyLFsnJywneyddKTtcbiB9OyRozY9fb25jZS5pbnRlcnNlY3RSYW5rQ292ZXJzKGludGVyc2VjdFJhbmtDb3ZlcnMpO1xuXG5jb25zdCAgICAgICB7Y29tcGFyYXRvcjpjb21wYXJlUmFuayxhbnRpQ29tcGFyYXRvcjpjb21wYXJlQW50aVJhbmt9PVxubWFrZUNvbXBhcmF0b3JLaXQoKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjb21wYXJhdG9yIGtpdCBpbiB3aGljaCByZW1vdGFibGVzIGFyZSBmdWxseSBvcmRlcmVkXG4gKiBieSB0aGUgb3JkZXIgaW4gd2hpY2ggdGhleSBhcmUgZmlyc3Qgc2VlbiBieSAqdGhpcyogY29tcGFyYXRvciBraXQuXG4gKiBCRVdBUkU6IFRoaXMgaXMgb2JzZXJ2YWJsZSBtdXRhYmxlIHN0YXRlLCBzbyBzdWNoIGEgY29tcGFyYXRvciBraXRcbiAqIHNob3VsZCBuZXZlciBiZSBzaGFyZWQgYW1vbmcgc3Vic3lzdGVtcyB0aGF0IHNob3VsZCBub3QgYmUgYWJsZVxuICogdG8gY29tbXVuaWNhdGUuXG4gKlxuICogTm90ZSB0aGF0IHRoaXMgb3JkZXIgZG9lcyBub3QgbWVldCB0aGUgcmVxdWlyZW1lbnRzIGZvciBzdG9yZVxuICogb3JkZXJpbmcsIHNpbmNlIGl0IGhhcyBubyBtZW1vcnkgb2YgZGVsZXRlZCBrZXlzLlxuICpcbiAqIFRoZXNlIGZ1bGwgb3JkZXIgY29tcGFyYXRvciBraXQgaXMgc3RyaWN0bHkgbW9yZSBwcmVjaXNlIHRoYXQgdGhlXG4gKiByYW5rIG9yZGVyIGNvbXBhcmF0b3Iga2l0cyBhYm92ZS4gQXMgYSByZXN1bHQsIGFueSBhcnJheSB3aGljaCBpc1xuICogc29ydGVkIGJ5IHN1Y2ggYSBmdWxsIG9yZGVyIHdpbGwgcGFzcyB0aGUgaXNSYW5rU29ydGVkIHRlc3Qgd2l0aFxuICogYSBjb3JyZXNwb25kaW5nIHJhbmsgb3JkZXIuXG4gKlxuICogQW4gYXJyYXkgd2hpY2ggaXMgc29ydGVkIGJ5IGEgKmZyZXNoKiBmdWxsIG9yZGVyIGNvbXBhcmF0b3IsIGkuZS4sXG4gKiBvbmUgdGhhdCBoYXMgbm90IHlldCBzZWVuIGFueSByZW1vdGFibGVzLCB3aWxsIG9mIGNvdXJzZSByZW1haW5cbiAqIHNvcnRlZCBieSBhY2NvcmRpbmcgdG8gKnRoYXQqIGZ1bGwgb3JkZXIgY29tcGFyYXRvci4gQW4gYXJyYXkgKm9mXG4gKiBzY2FsYXJzKiBzb3J0ZWQgYnkgYSBmcmVzaCBmdWxsIG9yZGVyIHdpbGwgcmVtYWluIHNvcnRlZCBldmVuXG4gKiBhY2NvcmRpbmcgdG8gYSBuZXcgZnJlc2ggZnVsbCBvcmRlciBjb21wYXJhdG9yLCBzaW5jZSBpdCB3aWxsIHNlZVxuICogdGhlIHJlbW90YWJsZXMgaW4gdGhlIHNhbWUgb3JkZXIgYWdhaW4uIFVuZm9ydHVuYXRlbHksIHRoaXMgaXNcbiAqIG5vdCB0cnVlIG9mIGFycmF5cyBvZiBwYXNzYWJsZXMgaW4gZ2VuZXJhbC5cbiAqXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBsb25nTGl2ZWRcbiAqIEByZXR1cm5zIHtGdWxsQ29tcGFyYXRvcktpdH1cbiAqLyRozY9fb25jZS5jb21wYXJlUmFuayhjb21wYXJlUmFuayk7JGjNj19vbmNlLmNvbXBhcmVBbnRpUmFuayhjb21wYXJlQW50aVJhbmspO1xuY29uc3QgICAgICAgIG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0PShsb25nTGl2ZWQ9ZmFsc2UpPT57XG5sZXQgbnVtU2Vlbj0wO1xuLyogV2hlbiBkeW5hbWljYWxseSBjcmVhdGVkIHdpdGggc2hvcnQgbGlmZXRpbWVzICh0aGUgZGVmYXVsdCkgYSBXZWFrTWFwKi9cbi8qIHdvdWxkIHBlcmZvcm0gcG9vcmx5LCBhbmQgdGhlIGxlYWsgY3JlYXRlZCBieSBhIE1hcCBvbmx5IGxhc3RzIGFzIGxvbmcqL1xuLyogYXMgdGhlIE1hcC4qL1xuY29uc3QgTWFwQ29uc3RydWN0b3I9bG9uZ0xpdmVkP1dlYWtNYXA6TWFwO1xuY29uc3Qgc2Vlbj1uZXcgTWFwQ29uc3RydWN0b3IoKTtcbmNvbnN0IHRhZz0ocik9PntcbmlmKHNlZW4uaGFzKHIpKXtcbnJldHVybiBzZWVuLmdldChyKTtcbiB9XG5udW1TZWVuKz0xO1xuc2Vlbi5zZXQocixudW1TZWVuKTtcbnJldHVybiBudW1TZWVuO1xuIH07XG5jb25zdCBjb21wYXJlUmVtb3RhYmxlcz0oeCx5KT0+Y29tcGFyZVJhbmsodGFnKHgpLHRhZyh5KSk7XG5yZXR1cm4gbWFrZUNvbXBhcmF0b3JLaXQoY29tcGFyZVJlbW90YWJsZXMpO1xuIH07JGjNj19vbmNlLm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KTtcbmhhcmRlbihtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cml2aWFsQ29tcGFyYXRvciI6WyJ0cml2aWFsQ29tcGFyYXRvciJdLCJnZXRQYXNzU3R5bGVDb3ZlciI6WyJnZXRQYXNzU3R5bGVDb3ZlciJdLCJtYWtlQ29tcGFyYXRvcktpdCI6WyJtYWtlQ29tcGFyYXRvcktpdCJdLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiOlsiY29tcGFyYXRvck1pcnJvckltYWdlIl0sImlzUmFua1NvcnRlZCI6WyJpc1JhbmtTb3J0ZWQiXSwiYXNzZXJ0UmFua1NvcnRlZCI6WyJhc3NlcnRSYW5rU29ydGVkIl0sInNvcnRCeVJhbmsiOlsic29ydEJ5UmFuayJdLCJnZXRJbmRleENvdmVyIjpbImdldEluZGV4Q292ZXIiXSwiRnVsbFJhbmtDb3ZlciI6WyJGdWxsUmFua0NvdmVyIl0sImNvdmVyZWRFbnRyaWVzIjpbImNvdmVyZWRFbnRyaWVzIl0sInVuaW9uUmFua0NvdmVycyI6WyJ1bmlvblJhbmtDb3ZlcnMiXSwiaW50ZXJzZWN0UmFua0NvdmVycyI6WyJpbnRlcnNlY3RSYW5rQ292ZXJzIl0sImNvbXBhcmVSYW5rIjpbImNvbXBhcmVSYW5rIl0sImNvbXBhcmVBbnRpUmFuayI6WyJjb21wYXJlQW50aVJhbmsiXSwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiOlsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAai91qtYLAADWCwAAHgAAAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiTmF0IiwiaXNOYXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc05hdCwgJ25hbWUnLCB7dmFsdWU6IFwiaXNOYXRcIn0pOyRozY9fb25jZS5pc05hdChpc05hdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KE5hdCwgJ25hbWUnLCB7dmFsdWU6IFwiTmF0XCJ9KTskaM2PX29uY2UuTmF0KE5hdCk7ICAgLyogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuKi9cbi8qIENvcHlyaWdodCAoQykgMjAxOCBBZ29yaWMqL1xuLyoqL1xuLyogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTsqL1xuLyogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLiovXG4vKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQqL1xuLyoqL1xuLyogaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKi9cbi8qKi9cbi8qIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUqL1xuLyogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLCovXG4vKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4qL1xuLyogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCovXG4vKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4qL1xuXG4vKiBAdHMtY2hlY2sqL1xuXG4vKipcbiAqIElzIGBhbGxlZ2VkTnVtYCBhIG51bWJlciBpbiB0aGUgW2NvbnRpZ3VvdXMgcmFuZ2Ugb2YgZXhhY3RseSBhbmRcbiAqIHVuYW1iaWd1b3VzbHlcbiAqIHJlcHJlc2VudGFibGVdKGh0dHBzOi8vZXNkaXNjdXNzLm9yZy90b3BpYy9tb3JlLW51bWVyaWMtY29uc3RhbnRzLXBsZWFzZS1lc3BlY2lhbGx5LWVwc2lsb24jY29udGVudC0xNClcbiAqICBuYXR1cmFsIG51bWJlcnMgKG5vbi1uZWdhdGl2ZSBpbnRlZ2Vycyk/XG4gKlxuICogVG8gcXVhbGlmeSBgYWxsZWdlZE51bWAgbXVzdCBlaXRoZXIgYmUgYVxuICogbm9uLW5lZ2F0aXZlIGBiaWdpbnRgLCBvciBhIG5vbi1uZWdhdGl2ZSBgbnVtYmVyYCByZXByZXNlbnRpbmcgYW4gaW50ZWdlclxuICogd2l0aGluIHJhbmdlIG9mIFtpbnRlZ2VycyBzYWZlbHkgcmVwcmVzZW50YWJsZSBpblxuICogZmxvYXRpbmcgcG9pbnRdKGh0dHBzOi8vdGMzOS5lcy9lY21hMjYyLyNzZWMtbnVtYmVyLmlzc2FmZWludGVnZXIpLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gYWxsZWdlZE51bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmZ1bmN0aW9uIGlzTmF0KGFsbGVnZWROdW0pe1xuaWYodHlwZW9mIGFsbGVnZWROdW09PT0nYmlnaW50Jyl7XG5yZXR1cm4gYWxsZWdlZE51bT49MDtcbiB9XG5pZih0eXBlb2YgYWxsZWdlZE51bSE9PSdudW1iZXInKXtcbnJldHVybiBmYWxzZTtcbiB9XG5cbnJldHVybiBOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSYmYWxsZWdlZE51bT49MDtcbiB9XG5cbi8qKlxuICogSWYgYGFsbGVnZWROdW1iZXJgIHBhc3NlcyB0aGUgYGlzTmF0YCB0ZXN0LCB0aGVuIHJldHVybiBpdCBhcyBhIGJpZ2ludC5cbiAqIE90aGVyd2lzZSB0aHJvdyBhbiBhcHByb3ByaWF0ZSBlcnJvci5cbiAqXG4gKiBJZiBgYWxsZWdlZE51bWAgaXMgbmVpdGhlciBhIGJpZ2ludCBub3IgYSBudW1iZXIsIGBOYXRgIHRocm93cyBhIGBUeXBlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpZiBpdCBpcyBub3QgYSBbc2FmZWx5XG4gKiByZXByZXNlbnRhYmxlXShodHRwczovL2VzZGlzY3Vzcy5vcmcvdG9waWMvbW9yZS1udW1lcmljLWNvbnN0YW50cy1wbGVhc2UtZXNwZWNpYWxseS1lcHNpbG9uI2NvbnRlbnQtMTQpXG4gKiBub24tbmVnYXRpdmUgaW50ZWdlciwgYE5hdGAgdGhyb3dzIGEgYFJhbmdlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpdCBpcyBjb252ZXJ0ZWQgdG8gYSBiaWdpbnQgaWYgbmVjZXNzYXJ5IGFuZCByZXR1cm5lZC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGFsbGVnZWROdW1cbiAqIEByZXR1cm5zIHtiaWdpbnR9XG4gKi9cbmZ1bmN0aW9uIE5hdChhbGxlZ2VkTnVtKXtcbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J2JpZ2ludCcpe1xuaWYoYWxsZWdlZE51bTwwKXtcbnRocm93IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIGFsbGVnZWROdW07XG4gfVxuXG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdudW1iZXInKXtcbmlmKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSl7XG50aHJvdyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBpcyBub3QgYSBzYWZlIGludGVnZXJgKTtcbiB9XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gaXMgbmVnYXRpdmVgKTtcbiB9XG5yZXR1cm4gQmlnSW50KGFsbGVnZWROdW0pO1xuIH1cblxudGhyb3cgVHlwZUVycm9yKFxuIGAke2FsbGVnZWROdW19IGlzIGEgJHt0eXBlb2YgYWxsZWdlZE51bX0gYnV0IG11c3QgYmUgYSBiaWdpbnQgb3IgYSBudW1iZXJgKTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzTmF0IjpbImlzTmF0Il0sIk5hdCI6WyJOYXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoSmqvD8KAAA/CgAAIAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvZXJyb3IuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy9zdHJpbmcuanMiLCIuL3NyYy9wYXNzU3R5bGVPZi5qcyIsIi4vc3JjL21ha2VUYWdnZWQuanMiLCIuL3NyYy9tYWtlLWZhci5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiLCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkZhciIsImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSIsImFzc2VydFdlbGxGb3JtZWRTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiLCJpc09iamVjdCIsImlzT2JqZWN0IiwiaXNQYXNzYWJsZSIsImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtbXCIuL3NyYy9pdGVyLWhlbHBlcnMuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9lcnJvci5qc1wiLCBbXV0sW1wiLi9zcmMvcmVtb3RhYmxlLmpzXCIsIFtdXSxbXCIuL3NyYy9zeW1ib2wuanNcIiwgW11dLFtcIi4vc3JjL3N0cmluZy5qc1wiLCBbXV0sW1wiLi9zcmMvcGFzc1N0eWxlT2YuanNcIiwgW11dLFtcIi4vc3JjL21ha2VUYWdnZWQuanNcIiwgW11dLFtcIi4vc3JjL21ha2UtZmFyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlR3VhcmRzLmpzXCIsIFtdXSxbXCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvaXRlci1oZWxwZXJzLmpzIjpbWyJtYXBJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sWyJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIl1dLCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6W1siUEFTU19TVFlMRSIsIlBBU1NfU1RZTEUiXSxbImlzT2JqZWN0IiwiaXNPYmplY3QiXSxbImFzc2VydENoZWNrZXIiLCJhc3NlcnRDaGVja2VyIl0sWyJnZXRUYWciLCJnZXRUYWciXSxbImhhc093blByb3BlcnR5T2YiLCJoYXNPd25Qcm9wZXJ0eU9mIl1dLCIuL3NyYy9lcnJvci5qcyI6W1siZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImdldEVycm9yQ29uc3RydWN0b3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3N0cmluZy5qcyI6W1siaXNXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sWyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyJdLFsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRQYXNzYWJsZVN0cmluZyJdXSwiLi9zcmMvcGFzc1N0eWxlT2YuanMiOltbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXSxbImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbInRvVGhyb3dhYmxlIiwidG9UaHJvd2FibGUiXV0sIi4vc3JjL21ha2VUYWdnZWQuanMiOltbIm1ha2VUYWdnZWQiLCJtYWtlVGFnZ2VkIl1dLCIuL3NyYy9tYWtlLWZhci5qcyI6W1siUmVtb3RhYmxlIiwiUmVtb3RhYmxlIl0sWyJGYXIiLCJGYXIiXSxbIlRvRmFyRnVuY3Rpb24iLCJUb0ZhckZ1bmN0aW9uIl0sWyJHRVRfTUVUSE9EX05BTUVTIiwiR0VUX01FVEhPRF9OQU1FUyJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAeYB/DAMIAAADCAAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLGFzc2VydENoZWNrZXIsZ2V0T3duRGF0YURlc2NyaXB0b3I7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRozY9fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheSxwcm90b3R5cGU6YXJyYXlQcm90b3R5cGV9PUFycmF5O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0lNUE9SVCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjYW5CZVZhbGlkPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5pc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmY2hlY2soZmFsc2UsWCBgQXJyYXkgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7SU1QT1JUKCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyBnZXQgdG8gZmFpbC4qL1xuY29uc3QgbGVuPS8qKiBAdHlwZSB7bnVtYmVyfSAqL1xuZ2V0T3duRGF0YURlc2NyaXB0b3IoY2FuZGlkYXRlLCdsZW5ndGgnLGZhbHNlLGFzc2VydENoZWNrZXIpLnZhbHVlO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggaW5kZXggcHJvcGVydHkgaXMgb3duL2RhdGEvZW51bWVyYWJsZSovXG4vKiBhbmQgaXRzIGFzc29jaWF0ZWQgdmFsdWUgaXMgcmVjdXJzaXZlbHkgcGFzc2FibGUuKi9cbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSxpLHRydWUsYXNzZXJ0Q2hlY2tlcikudmFsdWUpO1xuXG4gfVxuLyogRXhwZWN0IG9uZSBrZXkgcGVyIGluZGV4IHBsdXMgb25lIGZvciAnbGVuZ3RoJy4qL1xub3duS2V5cyhjYW5kaWRhdGUpLmxlbmd0aD09PWxlbisxfHxcbmFzc2VydC5mYWlsKFggYEFycmF5cyBtdXN0IG5vdCBoYXZlIG5vbi1pbmRleGVzOiAke2NhbmRpZGF0ZX1gLFR5cGVFcnJvcik7XG4gfX0pOyRozY9fb25jZS5Db3B5QXJyYXlIZWxwZXIoQ29weUFycmF5SGVscGVyKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlBcnJheUhlbHBlciI6WyJDb3B5QXJyYXlIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAArHWRoUkKAABJCgAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJDb3B5UmVjb3JkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGFzc2VydENoZWNrZXIsY2FuQmVNZXRob2QsZ2V0T3duRGF0YURlc2NyaXB0b3IsQ1g7JGjNj19pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiZ2V0T3duRGF0YURlc2NyaXB0b3JcIiwgWyRozY9fYSA9PiAoZ2V0T3duRGF0YURlc2NyaXB0b3IgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0UHJvdG90eXBlT2YscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tPYmplY3RQcm90b3R5cGU9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpPT09b2JqZWN0UHJvdG90eXBlfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZWNvcmRzIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7Y2FuZGlkYXRlfWApO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtQcm9wZXJ0eUtleX0ga2V5XG4gKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxrZXksdmFsdWUsY2hlY2s9dW5kZWZpbmVkKT0+e1xucmV0dXJuKFxuKHR5cGVvZiBrZXk9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkmJihcbiFjYW5CZU1ldGhvZCh2YWx1ZSl8fFxuISFjaGVjayYmXG4vKiBUT0RPOiBVcGRhdGUgbWVzc2FnZSBub3cgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIFwiaW1wbGljaXQgUmVtb3RhYmxlXCIuKi9cbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2Fubm90IGNvbnRhaW4gbm9uLWZhciBmdW5jdGlvbnMgYmVjYXVzZSB0aGV5IG1heSBiZSBtZXRob2RzIG9mIGFuIGltcGxpY2l0IFJlbW90YWJsZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfTtcblxuLyoqXG4gKlxuICogQHR5cGUge0lNUE9SVCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5jaGVja09iamVjdFByb3RvdHlwZShjYW5kaWRhdGUsY2hlY2spJiZcbi8qIFJlamVjdCBhbnkgY2FuZGlkYXRlIHdpdGggYSBzeW1ib2wta2V5ZWQgcHJvcGVydHkgb3IgbWV0aG9kLWxpa2UgcHJvcGVydHkqL1xuLyogKHN1Y2ggaW5wdXQgaXMgcG90ZW50aWFsbHkgYSBSZW1vdGFibGUpLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkuZXZlcnkoKGtleSk9PlxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLGtleSxjYW5kaWRhdGVba2V5XSxjaGVjaykpKTtcblxuXG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2hlY2tPYmplY3RQcm90b3R5cGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggb3duIHByb3BlcnR5IGlzIGFwcHJvcHJpYXRlLCBkYXRhL2VudW1lcmFibGUsKi9cbi8qIGFuZCBoYXMgYSByZWN1cnNpdmVseSBwYXNzYWJsZSBhc3NvY2lhdGVkIHZhbHVlLiovXG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY29uc3R7dmFsdWV9PWdldE93bkRhdGFEZXNjcmlwdG9yKFxuY2FuZGlkYXRlLFxubmFtZSxcbnRydWUsXG5hc3NlcnRDaGVja2VyKTtcblxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLG5hbWUsdmFsdWUsYXNzZXJ0Q2hlY2tlcik7XG5wYXNzU3R5bGVPZlJlY3VyKHZhbHVlKTtcbiB9XG4gfX0pOyRozY9fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weVJlY29yZEhlbHBlciI6WyJDb3B5UmVjb3JkSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9wcm9taXNlLWtpdCIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIiwiLi9tYWtlVGFnZ2VkLmpzIl0sImV4cG9ydHMiOlsiZGVlcGx5RnVsZmlsbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IFgscSxFLGlzUHJvbWlzZSxnZXRUYWcsaXNPYmplY3QscGFzc1N0eWxlT2YsbWFrZVRhZ2dlZDskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRozY9fYSA9PiAoRSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJpc09iamVjdFwiLCBbJGjNj19hID0+IChpc09iamVjdCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dXV0sW1wiLi9tYWtlVGFnZ2VkLmpzXCIsIFtbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUHJpbWl0aXZlLCBDb3B5UmVjb3JkLCBDb3B5QXJyYXksIENvcHlUYWdnZWQsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSdcbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7ZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7eyBbS2V5VHlwZSBpbiBrZXlvZiBUXTogVFtLZXlUeXBlXSB9ICYge319IFNpbXBsaWZ5IGZsYXR0ZW4gdGhlXG4gKiAgIHR5cGUgb3V0cHV0IHRvIGltcHJvdmUgdHlwZSBoaW50cyBzaG93biBpbiBlZGl0b3JzXG4gKiAgIGh0dHBzOi8vZ2l0aHViLmNvbS9zaW5kcmVzb3JodXMvdHlwZS1mZXN0L2Jsb2IvbWFpbi9zb3VyY2Uvc2ltcGxpZnkuZC50c1xuICovXG5cbi8qKlxuICogQ3VycmVudGx5IGNvcGllZCBmcm9tIEBhZ29yaWMvaW50ZXJuYWwgdXRpbHMuanMuXG4gKiBUT0RPIFNob3VsZCBtaWdyYXRlIGhlcmUgYW5kIHRoZW4sIGlmIG5lZWRlZCwgcmVleHBvcnRlZCB0aGVyZS5cbiAqXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IENhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtLIGluIGtleW9mIFRdOiBUW0tdIGV4dGVuZHMgQ2FsbGFibGUgPyBUW0tdIDogRGVlcGx5QXdhaXRlZDxUW0tdPjtcbiAqIH19IERlZXBseUF3YWl0ZWRPYmplY3RcbiAqL1xuXG4vKipcbiAqIEN1cnJlbnRseSBjb3BpZWQgZnJvbSBAYWdvcmljL2ludGVybmFsIHV0aWxzLmpzLlxuICogVE9ETyBTaG91bGQgbWlncmF0ZSBoZXJlIGFuZCB0aGVuLCBpZiBuZWVkZWQsIHJlZXhwb3J0ZWQgdGhlcmUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgUHJvbWlzZUxpa2U8YW55PlxuICogICAgID8gQXdhaXRlZDxUPlxuICogICAgIDogVCBleHRlbmRzIHt9XG4gKiAgICAgICA/IFNpbXBsaWZ5PERlZXBseUF3YWl0ZWRPYmplY3Q8VD4+XG4gKiAgICAgICA6IEF3YWl0ZWQ8VD59IERlZXBseUF3YWl0ZWRcbiAqL1xuXG4vKipcbiAqIEdpdmVuIGEgUGFzc2FibGUgYHZhbGAgd2hvc2UgcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBtYXkgY29udGFpbiBsZWFmXG4gKiBwcm9taXNlcywgcmV0dXJuIGEgcHJvbWlzZSBmb3IgYSByZXBsYWNlbWVudCBQYXNzYWJsZSxcbiAqIHdoZXJlIHRoYXQgcmVwbGFjZW1lbnQgaXMgKmRlZXBseSBmdWxmaWxsZWQqLCBpLmUuLCBpdHNcbiAqIHBhc3MtYnktY29weSBzdHJ1Y3R1cmUgZG9lcyBub3QgY29udGFpbiBhbnkgcHJvbWlzZXMuXG4gKlxuICogVGhpcyBpcyBhIGRlZXAgZm9ybSBvZiBgUHJvbWlzZS5hbGxgIHNwZWNpYWxpemVkIGZvciBQYXNzYWJsZXMuIEZvciBlYWNoXG4gKiBlbmNvdW50ZXJlZCBwcm9taXNlLCByZXBsYWNlIGl0IHdpdGggdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybSBvZlxuICogaXRzIGZ1bGZpbGxtZW50LlxuICogSWYgYW55IG9mIHRoZSBwcm9taXNlcyByZWplY3QsIHRoZW4gdGhlIHByb21pc2UgZm9yIHRoZSByZXBsYWNlbWVudFxuICogcmVqZWN0cy4gSWYgYW55IG9mIHRoZSBwcm9taXNlcyBuZXZlciBzZXR0bGUsIHRoZW4gdGhlIHByb21pc2UgZm9yXG4gKiB0aGUgcmVwbGFjZW1lbnQgbmV2ZXIgc2V0dGxlcy5cbiAqXG4gKiBJZiB0aGUgcmVwbGFjZW1lbnQgd291bGQgbm90IGJlIFBhc3NhYmxlLCBpLmUuLCBpZiBgdmFsYCBpcyBub3RcbiAqIFBhc3NhYmxlLCBvciBpZiBhbnkgb2YgdGhlIHRyYW5zaXRpdmUgcHJvbWlzZXMgZnVsZmlsbCB0byBzb21ldGhpbmdcbiAqIHRoYXQgaXMgbm90IFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBwcm9taXNlIHJlamVjdHMuXG4gKlxuICogSWYgYHZhbGAgb3IgaXRzIHBhcnRzIGFyZSBub24ta2V5IFBhc3NhYmxlcyBvbmx5ICpiZWNhdXNlKiB0aGV5IGNvbnRhaW5cbiAqIHByb21pc2VzLCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtcyBvZiB2YWwgb3IgaXRzIHBhcnRzIG1heSBiZSBrZXlzLiBUaGlzXG4gKiBpcyBmb3IgdGhlIGhpZ2hlciBcIkBlbmRvL3BhdHRlcm5zXCIgbGV2ZWwgb2YgYWJzdHJhY3Rpb24gdG8gZGV0ZXJtaW5lLFxuICogYmVjYXVzZSBpdCBkZWZpbmVzIHRoZSBgS2V5YCBub3Rpb24gaW4gcXVlc3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Q9UGFzc2FibGVdXG4gKiBAcGFyYW0ge1R9IHZhbFxuICogQHJldHVybnMge1Byb21pc2U8RGVlcGx5QXdhaXRlZDxUPj59XG4gKi9cbmNvbnN0ICAgICAgICBkZWVwbHlGdWxmaWxsZWQ9YXN5bmModmFsKT0+e1xuLyogVE9ETyBGaWd1cmUgb3V0IHdoeSB3ZSBuZWVkIHRoZXNlIGF0LWV4cGVjdC1lcnJvciBkaXJlY3RpdmVzIGJlbG93Ki9cbi8qIGFuZCBmaXggaWYgcG9zc2libGUuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTI1NyBtYXkgYmUgcmVsZXZhbnQuKi9cblxuaWYoIWlzT2JqZWN0KHZhbCkpe1xucmV0dXJuICgvKiogQHR5cGUge0RlZXBseUF3YWl0ZWQ8VD59ICovdmFsKTtcbiB9XG5pZihpc1Byb21pc2UodmFsKSl7XG5yZXR1cm4gRS53aGVuKHZhbCwobm9ucCk9PmRlZXBseUZ1bGZpbGxlZChub25wKSk7XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbCk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnY29weVJlY29yZCc6e1xuY29uc3QgcmVjPS8qKiBAdHlwZSB7Q29weVJlY29yZH0gKi92YWw7XG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjKTtcbmNvbnN0IHZhbFBzPW5hbWVzLm1hcCgobmFtZSk9PmRlZXBseUZ1bGZpbGxlZChyZWNbbmFtZV0pKTtcbi8qIEB0cy1leHBlY3QtZXJyb3Igbm90IGFzc2lnbmFibGUgdG8gdHlwZSAnRGVlcGx5QXdhaXRlZDxUPicqL1xucmV0dXJuIEUud2hlbihQcm9taXNlLmFsbCh2YWxQcyksKHZhbHMpPT5cbmhhcmRlbihmcm9tRW50cmllcyh2YWxzLm1hcCgoYyxpKT0+W25hbWVzW2ldLGNdKSkpKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5jb25zdCBhcnI9LyoqIEB0eXBlIHtDb3B5QXJyYXl9ICovdmFsO1xuY29uc3QgdmFsUHM9YXJyLm1hcCgocCk9PmRlZXBseUZ1bGZpbGxlZChwKSk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oUHJvbWlzZS5hbGwodmFsUHMpLCh2YWxzKT0+aGFyZGVuKHZhbHMpKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGdkPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi92YWw7XG5jb25zdCB0YWc9Z2V0VGFnKHRnZCk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oZGVlcGx5RnVsZmlsbGVkKHRnZC5wYXlsb2FkKSwocGF5bG9hZCk9PlxubWFrZVRhZ2dlZCh0YWcscGF5bG9hZCkpO1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IHJlbT0vKiogQHR5cGUge1JlbW90YWJsZU9iamVjdH0gKi92YWw7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiByZW07XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZXJyPS8qKiBAdHlwZSB7RXJyb3J9ICovdmFsO1xuLyogQHRzLWV4cGVjdC1lcnJvciBub3QgYXNzaWduYWJsZSB0byB0eXBlICdEZWVwbHlBd2FpdGVkPFQ+JyovXG5yZXR1cm4gZXJyO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcHJvbT0vKiogQHR5cGUge1Byb21pc2V9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi92YWw7XG5yZXR1cm4gRS53aGVuKHByb20sKG5vbnApPT5kZWVwbHlGdWxmaWxsZWQobm9ucCkpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoWCBgVW5leHBlY3RlZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9YCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9OyRozY9fb25jZS5kZWVwbHlGdWxmaWxsZWQoZGVlcGx5RnVsZmlsbGVkKTtcbmhhcmRlbihkZWVwbHlGdWxmaWxsZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVlcGx5RnVsZmlsbGVkIjpbImRlZXBseUZ1bGZpbGxlZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABREv3gLhsAAC4bAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yIiwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiLCJnZXRFcnJvckNvbnN0cnVjdG9yIiwiaXNFcnJvckxpa2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcSxhc3NlcnRDaGVja2VyLENYOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlSGVscGVyfSBmcm9tICcuL2ludGVybmFsLXR5cGVzLmpzJyAqL1xuLyoqIEBpbXBvcnQge0NoZWNrZXIsIFBhc3NTdHlsZSwgUGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsaGFzT3duLGVudHJpZXN9PU9iamVjdDtcblxuLyogVE9ETzogTWFpbnRlbmFuY2UgaGF6YXJkOiBDb29yZGluYXRlIHdpdGggdGhlIGxpc3Qgb2YgZXJyb3JzIGluIHRoZSBTRVMqL1xuLyogd2hpbGVsaXN0LiovXG5jb25zdCBlcnJvckNvbnN0cnVjdG9ycz1uZXcgTWFwKFxuLyogQ2FzdCBiZWNhdXNlIG90aGVyd2lzZSBUUyBpcyBjb25mdXNlZCBieSBBZ2dyZWdhdGVFcnJvciovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMjA0MiNkaXNjdXNzaW9uX3IxNDg0OTMzMDI4Ki9cbi8qKiBAdHlwZSB7QXJyYXk8W3N0cmluZywgSU1QT1JUKCdzZXMnKS5HZW5lcmljRXJyb3JDb25zdHJ1Y3Rvcl0+fSAqL1xuW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1cblxuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy81NTAqL1xuLyogVG8gYWNjb21tb2RhdGUgcGxhdGZvcm1zIHByaW9yIHRvIEFnZ3JlZ2F0ZUVycm9yLCB3ZSBjb21tZW50IG91dCB0aGUqL1xuLyogZm9sbG93aW5nIGxpbmUgYW5kIGluc3RlYWQgY29uZGl0aW9uYWxseSBhZGQgaXQgdG8gdGhlIG1hcCBiZWxvdy4qL1xuLyogWydBZ2dyZWdhdGVFcnJvcicsIEFnZ3JlZ2F0ZUVycm9yXSwqL10pO1xuXG5cblxuaWYodHlwZW9mIEFnZ3JlZ2F0ZUVycm9yIT09J3VuZGVmaW5lZCcpe1xuLyogQ29uZGl0aW9uYWwsIHRvIGFjY29tbW9kYXRlIHBsYXRmb3JtcyBwcmlvciB0byBBZ2dyZWdhdGVFcnJvciovXG5lcnJvckNvbnN0cnVjdG9ycy5zZXQoJ0FnZ3JlZ2F0ZUVycm9yJyxBZ2dyZWdhdGVFcnJvcik7XG4gfVxuXG4vKipcbiAqIEJlY2F1c2UgdGhlIGVycm9yIGNvbnN0cnVjdG9yIHJldHVybmVkIGJ5IHRoaXMgZnVuY3Rpb24gbWlnaHQgYmVcbiAqIGBBZ2dyZWdhdGVFcnJvcmAsIHdoaWNoIGhhcyBkaWZmZXJlbnQgY29uc3RydWN0aW9uIHBhcmFtZXRlcnNcbiAqIGZyb20gdGhlIG90aGVyIGVycm9yIGNvbnN0cnVjdG9ycywgZG8gbm90IHVzZSBpdCBkaXJlY3RseSB0byB0cnlcbiAqIHRvIG1ha2UgYW4gZXJyb3IgaW5zdGFuY2UuIFJhdGhlciwgdXNlIGBtYWtlRXJyb3JgIHdoaWNoIGVuY2Fwc3VsYXRlc1xuICogdGhpcyBub24tdW5pZm9ybWl0eS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge0lNUE9SVCgnc2VzJykuR2VuZXJpY0Vycm9yQ29uc3RydWN0b3IgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRFcnJvckNvbnN0cnVjdG9yPShuYW1lKT0+ZXJyb3JDb25zdHJ1Y3RvcnMuZ2V0KG5hbWUpOyRozY9fb25jZS5nZXRFcnJvckNvbnN0cnVjdG9yKGdldEVycm9yQ29uc3RydWN0b3IpO1xuaGFyZGVuKGdldEVycm9yQ29uc3RydWN0b3IpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja0Vycm9yTGlrZT0oY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9Pntcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxuISFjaGVjayYmQ1goY2hlY2spIGBFcnJvciBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbiB9O1xuaGFyZGVuKGNoZWNrRXJyb3JMaWtlKTtcbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogVmFsaWRhdGluZyBlcnJvciBvYmplY3RzIGFyZSBwYXNzYWJsZSByYWlzZXMgYSB0ZW5zaW9uIGJldHdlZW4gc2VjdXJpdHlcbiAqIHZzIHByZXNlcnZpbmcgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gRm9yIGVycm9ycywgd2UgbmVlZCB0byByZW1lbWJlclxuICogdGhlIGVycm9yIGl0c2VsZiBleGlzdHMgdG8gaGVscCB1cyBkaWFnbm9zZSBhIGJ1ZyB0aGF0J3MgbGlrZWx5IG1vcmVcbiAqIHByZXNzaW5nIHRoYW4gYSB2YWxpZGl0eSBidWcgaW4gdGhlIGVycm9yIGl0c2VsZi4gVGh1cywgd2hlbmV2ZXIgaXQgaXMgc2FmZVxuICogdG8gZG8gc28sIHdlIHByZWZlciB0byBsZXQgdGhlIGVycm9yLWxpa2UgdGVzdCBzdWNjZWVkIGFuZCB0byBjb3VjaCB0aGVzZVxuICogY29tcGxhaW50cyBhcyBub3RlcyBvbiB0aGUgZXJyb3IuXG4gKlxuICogVG8gcmVzb2x2ZSB0aGlzLCBzdWNoIGEgbWFsZm9ybWVkIGVycm9yIG9iamVjdCB3aWxsIHN0aWxsIHBhc3NcbiAqIGBpc0Vycm9yTGlrZWAgc28gbWFyc2hhbCBjYW4gdXNlIHRoaXMgZm9yIHRvcCBsZXZlbCBlcnJvciB0byByZXBvcnQgZnJvbSxcbiAqIGV2ZW4gaWYgaXQgd291bGQgbm90IGFjdHVhbGx5IHZhbGlkYXRlLlxuICogSW5zdGVhZCwgdGhlIGRpYWdub3N0aWNzIHRoYXQgYGFzc2VydEVycm9yYCB3b3VsZCBoYXZlIHJlcG9ydGVkIGFyZVxuICogYXR0YWNoZWQgYXMgbm90ZXMgdG8gdGhlIG1hbGZvcm1lZCBlcnJvci4gVGh1cywgYSBtYWxmb3JtZWRcbiAqIGVycm9yIGlzIHBhc3NhYmxlIGJ5IGl0c2VsZiwgYnV0IG5vdCBhcyBwYXJ0IG9mIGEgcGFzc2FibGUgc3RydWN0dXJlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzRXJyb3JMaWtlPShjYW5kaWRhdGUpPT5jaGVja0Vycm9yTGlrZShjYW5kaWRhdGUpOyRozY9fb25jZS5pc0Vycm9yTGlrZShpc0Vycm9yTGlrZSk7XG5oYXJkZW4oaXNFcnJvckxpa2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBwcm9wTmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEBwYXJhbSB7KHZhbDogYW55KSA9PiBQYXNzU3R5bGV9IHBhc3NTdHlsZU9mUmVjdXJcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYz0oXG5wcm9wTmFtZSxcbmRlc2MsXG5wYXNzU3R5bGVPZlJlY3VyLFxuY2hlY2s9dW5kZWZpbmVkKT0+XG57XG5pZihkZXNjLmVudW1lcmFibGUpe1xucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yICR7cShcbnByb3BOYW1lKVxuIH0gb3duIHByb3BlcnR5IG11c3Qgbm90IGJlIGVudW1lcmFibGU6ICR7ZGVzY31gKTtcblxuIH1cbmlmKCFoYXNPd24oZGVzYywndmFsdWUnKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGRhdGEgcHJvcGVydHk6ICR7ZGVzY31gKTtcblxuIH1cbmNvbnN0e3ZhbHVlfT1kZXNjO1xuc3dpdGNoKHByb3BOYW1lKXtcbmNhc2UnbWVzc2FnZSc6XG5jYXNlJ3N0YWNrJzp7XG5yZXR1cm4oXG50eXBlb2YgdmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt2YWx1ZX1gKTtcblxuIH1cbmNhc2UnY2F1c2UnOntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IodmFsdWUscGFzc1N0eWxlT2ZSZWN1cixjaGVjayk7XG4gfVxuY2FzZSdlcnJvcnMnOntcbmlmKCFBcnJheS5pc0FycmF5KHZhbHVlKXx8cGFzc1N0eWxlT2ZSZWN1cih2YWx1ZSkhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGNvcHlBcnJheTogJHt2YWx1ZX1gKTtcblxuIH1cbnJldHVybiB2YWx1ZS5ldmVyeSgoZXJyKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mUmVjdXIsY2hlY2spKTtcblxuIH1cbmRlZmF1bHQ6e1xuYnJlYWs7XG4gfX1cblxucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yIGhhcyBleHRyYSB1bnBhc3NlZCBwcm9wZXJ0eSAke3EocHJvcE5hbWUpfWApO1xuXG4gfTskaM2PX29uY2UuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MpO1xuaGFyZGVuKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHsodmFsOiBhbnkpID0+IFBhc3NTdHlsZX0gcGFzc1N0eWxlT2ZSZWN1clxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yPShcbmNhbmRpZGF0ZSxcbnBhc3NTdHlsZU9mUmVjdXIsXG5jaGVjaz11bmRlZmluZWQpPT5cbntcbmlmKCFjaGVja0Vycm9yTGlrZShjYW5kaWRhdGUsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpO1xuY29uc3R7bmFtZX09cHJvdG87XG5jb25zdCBlcnJDb25zdHJ1Y3Rvcj1nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpO1xuaWYoZXJyQ29uc3RydWN0b3I9PT11bmRlZmluZWR8fGVyckNvbnN0cnVjdG9yLnByb3RvdHlwZSE9PXByb3RvKXtcbnJldHVybihcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgUGFzc2FibGUgRXJyb3IgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCk7XG5cbiB9XG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZighKCdtZXNzYWdlJ2luIGRlc2NzKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFBhc3NhYmxlIEVycm9yIG11c3QgaGF2ZSBhbiBvd24gXCJtZXNzYWdlXCIgc3RyaW5nIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTtcblxuIH1cblxucmV0dXJuIGVudHJpZXMoZGVzY3MpLmV2ZXJ5KChbcHJvcE5hbWUsZGVzY10pPT5cbmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKFxucHJvcE5hbWUsXG5kZXNjLFxucGFzc1N0eWxlT2ZSZWN1cixcbmNoZWNrKSk7XG5cblxuIH07JGjNj19vbmNlLmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKTtcbmhhcmRlbihjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcik7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+XG5jaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cixhc3NlcnRDaGVja2VyKX0pOyRozY9fb25jZS5FcnJvckhlbHBlcihFcnJvckhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAu5h1k2cIAABnCAAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiLi9tYWtlLWZhci5qcyJdLCJleHBvcnRzIjpbImZpbHRlckl0ZXJhYmxlIiwibWFwSXRlcmFibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgRmFyOyRozY9faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaM2PX2EgPT4gKEZhciA9ICRozY9fYSldXV1dXSk7ICAgXG5cbi8qKlxuICogVGhlIHJlc3VsdCBpdGVyYXRvciBoYXMgYXMgbWFueSBlbGVtZW50cyBhcyB0aGUgYGJhc2VJdGVyYXRvcmAgYW5kXG4gKiBoYXZlIHRoZSBzYW1lIHRlcm1pbmF0aW9uIC0tIHRoZSBzYW1lIGNvbXBsZXRpb24gdmFsdWUgb3IgZmFpbHVyZVxuICogcmVhc29uLiBCdXQgdGhlIG5vbi1maW5hbCB2YWx1ZXMgYXJlIHRoZSBjb3JyZXNwb25kaW5nIG5vbi1maW5hbFxuICogdmFsdWVzIGZyb20gYGJhc2VJdGVyYXRvcmAgYXMgdHJhbnNmb3JtZWQgYnkgYGZ1bmNgLlxuICpcbiAqIEB0ZW1wbGF0ZSBULFVcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IGJhc2VJdGVyYWJsZVxuICogQHBhcmFtIHsodmFsdWU6IFQpID0+IFV9IGZ1bmNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxVPn1cbiAqL1xuY29uc3QgICAgICAgIG1hcEl0ZXJhYmxlPShiYXNlSXRlcmFibGUsZnVuYyk9PlxuLyoqIEB0eXBlIHtJdGVyYWJsZTxVPn0gKi9cbkZhcignbWFwcGVkIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgYmFzZUl0ZXJhdG9yPWJhc2VJdGVyYWJsZVtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gRmFyKCdtYXBwZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmNvbnN0e3ZhbHVlOmJhc2VWYWx1ZSxkb25lfT1iYXNlSXRlcmF0b3IubmV4dCgpO1xuY29uc3QgdmFsdWU9ZG9uZT9iYXNlVmFsdWU6ZnVuYyhiYXNlVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7dmFsdWUsZG9uZX0pO1xuIH19KTtcblxuIH19KTskaM2PX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjNj19vbmNlLmZpbHRlckl0ZXJhYmxlKGZpbHRlckl0ZXJhYmxlKTtcblxuaGFyZGVuKGZpbHRlckl0ZXJhYmxlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1hcEl0ZXJhYmxlIjpbIm1hcEl0ZXJhYmxlIl0sImZpbHRlckl0ZXJhYmxlIjpbImZpbHRlckl0ZXJhYmxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN5jxppcJAAAXCQAACcAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZS1mYXIuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyIsIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3JlbW90YWJsZS5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkdFVF9NRVRIT0RfTkFNRVMiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldE1ldGhvZE5hbWVzLHEsRmFpbCxhc3NlcnRDaGVja2VyLFBBU1NfU1RZTEUsYXNzZXJ0SWZhY2UsZ2V0SW50ZXJmYWNlT2YsUmVtb3RhYmxlSGVscGVyOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qc1wiLCBbW1wiZ2V0TWV0aG9kTmFtZXNcIiwgWyRozY9fYSA9PiAoZ2V0TWV0aG9kTmFtZXMgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcImFzc2VydElmYWNlXCIsIFskaM2PX2EgPT4gKGFzc2VydElmYWNlID0gJGjNj19hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaM2PX2EgPT4gKGdldEludGVyZmFjZU9mID0gJGjNj19hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge1JlbW90YWJsZUJyYW5kfSBmcm9tICdAZW5kby9ldmVudHVhbC1zZW5kJyAqL1xuLyoqIEBpbXBvcnQge0ludGVyZmFjZVNwZWMsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuY29uc3R7cHJvdG90eXBlOmZ1bmN0aW9uUHJvdG90eXBlfT1GdW5jdGlvbjtcbmNvbnN0e1xuZ2V0UHJvdG90eXBlT2YsXG5zZXRQcm90b3R5cGVPZixcbmNyZWF0ZSxcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09XG5PYmplY3Q7XG5cbi8qKlxuICogTm93IHRoYXQgdGhlIHJlbW90YWJsZVByb3RvIGRvZXMgbm90IHByb3ZpZGUgaXRzIG93biBgdG9TdHJpbmdgIG1ldGhvZCxcbiAqIGVuc3VyZSBpdCBhbHdheXMgaW5oZXJpdHMgZnJvbSBzb21ldGhpbmcuIFRoZSBvcmlnaW5hbCBwcm90b3R5cGUgb2ZcbiAqIGByZW1vdGFibGVgIGlmIHRoZXJlIHdhcyBvbmUsIG9yIGBPYmplY3QucHJvdG90eXBlYCBvdGhlcndpc2UuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IHJlbW90YWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHJldHVybnMge29iamVjdH1cbiAqL1xuY29uc3QgbWFrZVJlbW90YWJsZVByb3RvPShyZW1vdGFibGUsaWZhY2UpPT57XG5sZXQgb2xkUHJvdG89Z2V0UHJvdG90eXBlT2YocmVtb3RhYmxlKTtcbmlmKHR5cGVvZiByZW1vdGFibGU9PT0nb2JqZWN0Jyl7XG5pZihvbGRQcm90bz09PW51bGwpe1xub2xkUHJvdG89b2JqZWN0UHJvdG90eXBlO1xuIH1cbm9sZFByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbkZhaWwgYEZvciBub3csIHJlbW90YWJsZXMgY2Fubm90IGluaGVyaXQgZnJvbSBhbnl0aGluZyB1bnVzdWFsLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNlIGlmKHR5cGVvZiByZW1vdGFibGU9PT0nZnVuY3Rpb24nKXtcbm9sZFByb3RvIT09bnVsbHx8XG5GYWlsIGBPcmlnaW5hbCBmdW5jdGlvbiBtdXN0IG5vdCBpbmhlcml0IGZyb20gbnVsbDogJHtyZW1vdGFibGV9YDtcbm9sZFByb3RvPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuZ2V0UHJvdG90eXBlT2Yob2xkUHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuRmFpbCBgRmFyIGZ1bmN0aW9ucyBtdXN0IG9yaWdpbmFsbHkgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZSwgaW4gJHtyZW1vdGFibGV9YDtcbiB9ZWxzZXtcbkZhaWwgYHVucmVjb2duaXplZCB0eXBlb2YgJHtyZW1vdGFibGV9YDtcbiB9XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9sZFByb3RvLHtcbltQQVNTX1NUWUxFXTp7dmFsdWU6J3JlbW90YWJsZSd9LFxuW1N5bWJvbC50b1N0cmluZ1RhZ106e3ZhbHVlOmlmYWNlfX0pKTtcblxuXG4gfTtcblxuY29uc3QgYXNzZXJ0Q2FuQmVSZW1vdGFibGU9KGNhbmRpZGF0ZSk9PlxuUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENyZWF0ZSBhbmQgcmVnaXN0ZXIgYSBSZW1vdGFibGUuICBBZnRlciB0aGlzLCBnZXRJbnRlcmZhY2VPZihyZW1vdGFibGUpXG4gKiByZXR1cm5zIGlmYWNlLlxuICpcbiAqIC8vIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvODA0XG4gKlxuICogQHRlbXBsYXRlIHt7fX0gVFxuICogQHRlbXBsYXRlIHtJbnRlcmZhY2VTcGVjfSBJXG4gKiBAcGFyYW0ge0l9IFtpZmFjZV0gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHNdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlT2JqZWN0PEk+ICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fX0gcmVtb3RhYmxlLCBtb2RpZmllZCBmb3IgZGVidWdnYWJpbGl0eVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlPShcbi8qIEB0cy1leHBlY3QtZXJyb3IgSSBjb3VsZCBoYXZlIGRpZmZlcmVudCBzdWJ0eXBlIHRoYW4gc3RyaW5nKi9cbmlmYWNlPSdSZW1vdGFibGUnLFxucHJvcHM9dW5kZWZpbmVkLFxucmVtb3RhYmxlPS8qKiBAdHlwZSB7VH0gKi97fSk9Plxue1xuYXNzZXJ0SWZhY2UoaWZhY2UpO1xuYXNzZXJ0KGlmYWNlKTtcbi8qIFRPRE86IFdoZW4gaWZhY2UgaXMgcmljaGVyIHRoYW4ganVzdCBzdHJpbmcsIHdlIG5lZWQgdG8gZ2V0IHRoZSBhbGxlZ2VkTmFtZSovXG4vKiBpbiBhIGRpZmZlcmVudCB3YXkuKi9cbnByb3BzPT09dW5kZWZpbmVkfHxGYWlsIGBSZW1vdGFibGUgcHJvcHMgbm90IHlldCBpbXBsZW1lbnRlZCAke3Byb3BzfWA7XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgdGhhdCB0aGUgdW5tb2RpZmllZCBvYmplY3QgaXMgYWJsZSB0byBiZWNvbWUgYSBSZW1vdGFibGUuKi9cbmFzc2VydENhbkJlUmVtb3RhYmxlKHJlbW90YWJsZSk7XG5cbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBtYXJrZWQuKi9cbiEoUEFTU19TVFlMRSBpbiByZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBtYXJrZWQgYXMgYSAke3EoXG5yZW1vdGFibGVbUEFTU19TVFlMRV0pXG4gfWA7XG4vKiBgaXNGcm96ZW5gIGFsd2F5cyByZXR1cm5zIHRydWUgd2l0aCBhIGZha2UgYGhhcmRlbmAsIGJ1dCB3ZSB3YW50IHRoYXQgY2FzZSovXG4vKiB0byBzdWNjZWVkIGFueXdheS4gRmFraW5nIGBoYXJkZW5gIGlzIG9ubHkgY29ycmVjdG5lc3MgcHJlc2VydmluZyovXG4vKiBpZiB0aGUgY29kZSBpbiBxdWVzdGlvbiBjb250YWlucyBubyBidWdzIHRoYXQgdGhlIHJlYWwgYGhhcmRlbmAgd291bGQqL1xuLyogaGF2ZSBjYXVnaHQuKi9cbi8qIEB0cy1pZ25vcmUgYGlzRmFrZWAgcHVycG9zZWx5IG5vdCBpbiB0aGUgdHlwZSovXG5oYXJkZW4uaXNGYWtlfHxcbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBmcm96ZW4uKi9cbiFpc0Zyb3plbihyZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBmcm96ZW5gO1xuY29uc3QgcmVtb3RhYmxlUHJvdG89bWFrZVJlbW90YWJsZVByb3RvKHJlbW90YWJsZSxpZmFjZSk7XG5cbi8qIFRha2UgYSBzdGF0aWMgY29weSBvZiB0aGUgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBhcyBkYXRhIHByb3BlcnRpZXMuKi9cbi8qIGNvbnN0IHByb3BEZXNjcyA9IGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoeyAuLi5wcm9wcyB9KTsqL1xuY29uc3QgbXV0YXRlSGFyZGVuQW5kQ2hlY2s9KHRhcmdldCk9Pntcbi8qIGRlZmluZVByb3BlcnRpZXModGFyZ2V0LCBwcm9wRGVzY3MpOyovXG5zZXRQcm90b3R5cGVPZih0YXJnZXQscmVtb3RhYmxlUHJvdG8pO1xuaGFyZGVuKHRhcmdldCk7XG5hc3NlcnRDYW5CZVJlbW90YWJsZSh0YXJnZXQpO1xuIH07XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgYSBmcmVzaCByZW1vdGFibGUgdG8gc2VlIGlmIG91ciBydWxlcyBmaXQuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHt9KTtcblxuLyogQWN0dWFsbHkgZmluaXNoIHRoZSBuZXcgcmVtb3RhYmxlLiovXG5tdXRhdGVIYXJkZW5BbmRDaGVjayhyZW1vdGFibGUpO1xuXG4vKiBDT01NSVRURUQhKi9cbi8qIFdlJ3JlIGNvbW1pdHRlZCwgc28ga2VlcCB0aGUgaW50ZXJmYWNlIGZvciBmdXR1cmUgcmVmZXJlbmNlLiovXG5hc3NlcnQoaWZhY2UhPT11bmRlZmluZWQpOy8qIFRvIG1ha2UgVHlwZVNjcmlwdCBoYXBweSovXG5yZXR1cm4gKC8qKiBAdHlwZSB7YW55fSAqL3JlbW90YWJsZSk7XG4gfTskaM2PX29uY2UuUmVtb3RhYmxlKFJlbW90YWJsZSk7XG5oYXJkZW4oUmVtb3RhYmxlKTtcblxuLyoqXG4gKiBUaGUgbmFtZSBvZiB0aGUgYXV0b21hdGljYWxseSBhZGRlZCBkZWZhdWx0IG1ldGEtbWV0aG9kIGZvciBvYnRhaW5pbmcgYVxuICogbGlzdCBvZiBhbGwgbWV0aG9kcyBvZiBhbiBvYmplY3QgZGVjbGFyZWQgd2l0aCBgRmFyYCwgb3IgYW4gb2JqZWN0IHRoYXRcbiAqIGluaGVyaXRzIGZyb20gYW4gb2JqZWN0IGRlY2xhcmVkIHdpdGggYEZhcmAuXG4gKlxuICogTW9kZWxlZCBvbiBgR0VUX0lOVEVSRkFDRV9HVUFSRGAgZnJvbSBgQGVuZG8vZXhvYC5cbiAqXG4gKiBUT0RPIE5hbWUgdG8gYmUgYmlrZXNoZWQuIFBlcmhhcHMgZXZlbiB3aGV0aGVyIGl0IGlzIGFcbiAqIHN0cmluZyBvciBzeW1ib2wgdG8gYmUgYmlrZXNoZWQuIFNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTgwOSNkaXNjdXNzaW9uX3IxMzg4MDUyNDU0XG4gKlxuICogSEFaQVJEOiBCZXdhcmUgdGhhdCBhbiBleG8ncyBpbnRlcmZhY2UgY2FuIGNoYW5nZSBhY3Jvc3MgYW4gdXBncmFkZSxcbiAqIHNvIHJlbW90ZXMgdGhhdCBjYWNoZSBpdCBjYW4gYmVjb21lIHN0YWxlLlxuICovXG5jb25zdCAgICAgICAgR0VUX01FVEhPRF9OQU1FUz0nX19nZXRNZXRob2ROYW1lc19fJztcblxuLyoqXG4gKiBOb3RlIHRoYXQgYGdldE1ldGhvZE5hbWVzTWV0aG9kYCBpcyBhIHRoaXNmdWwgbWV0aG9kISBJdCBtdXN0IGJlIHNvIHRoYXRcbiAqIGl0IHdvcmtzIGFzIGV4cGVjdGVkIHdpdGggZmFyLW9iamVjdCBpbmhlcml0YW5jZS5cbiAqXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi8kaM2PX29uY2UuR0VUX01FVEhPRF9OQU1FUyhHRVRfTUVUSE9EX05BTUVTKTtcbmNvbnN0IGdldE1ldGhvZE5hbWVzTWV0aG9kPWhhcmRlbih7XG5bR0VUX01FVEhPRF9OQU1FU10oKXtcbnJldHVybiBnZXRNZXRob2ROYW1lcyh0aGlzKTtcbiB9fSlbXG5HRVRfTUVUSE9EX05BTUVTXTtcblxuY29uc3QgZ2V0TWV0aG9kTmFtZXNEZXNjcmlwdG9yPWhhcmRlbih7XG52YWx1ZTpnZXRNZXRob2ROYW1lc01ldGhvZCxcbmVudW1lcmFibGU6ZmFsc2UsXG5jb25maWd1cmFibGU6ZmFsc2UsXG53cml0YWJsZTpmYWxzZX0pO1xuXG5cbi8qKlxuICogTWFyayBhbiBvYmplY3QgdG8gYmUgZXhwb3NlZCBmb3IgcmVtb3RlIGludGVyYWN0aW9uXG4gKiBhbmQgZ2l2ZSBpdCBhIHN1Z2dlc3RpdmUgaW50ZXJmYWNlIG5hbWUgZm9yIGRlYnVnZ2luZy5cbiAqXG4gKiBBbGwgcHJvcGVydGllcyBvZiB0aGUgb2JqZWN0IGhhdmUgdG8gYmUgbWV0aG9kcywgbm90IGRhdGEuXG4gKlxuICogVGhlIG9iamVjdCBtdXN0IG5vdCBiZSBoYXJkZW5lZCBiZWZvcmUgaXQgaXMgbWFya2VkLlxuICogSXQgd2lsbCBiZSBoYXJkZW5lZCBhZnRlciBtYXJraW5nLlxuICpcbiAqIEZvciBmYXIgb2JqZWN0cyAoYXMgb3Bwb3NlZCB0byBmYXIgZnVuY3Rpb25zKSwgYWxzbyBhZGRzXG4gKiBgX19nZXRNZXRob2ROYW1lc19fYCBtZXRob2QgdGhhdCByZXR1cm5zIGFuIGFycmF5IG9mIGFsbCB0aGUgbWV0aG9kIG5hbWVzLFxuICogaWYgdGhlcmUgaXMgbm90IHlldCBhbnkgbWV0aG9kIG5hbWVkIGBfX2dldE1ldGhvZE5hbWVzX19gLlxuICpcbiAqIEBleGFtcGxlXG4gKiBGYXIoJ0VtcGxveWVlJywgeyBnZXRNYW5hZ2VyIH0pXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZmFyTmFtZSBUaGlzIG5hbWUgd2lsbCBiZSBwcmVwZW5kZWQgd2l0aCBgQWxsZWdlZDogYFxuICogZm9yIG5vdyB0byBmb3JtIHRoZSBgUmVtb3RhYmxlYCBgaWZhY2VgIGFyZ3VtZW50LlxuICogQHBhcmFtIHtUfSBbcmVtb3RhYmxlXSBUaGUgb2JqZWN0IHRvIGJlIG1hcmtlZCBhcyByZW1vdGFibGVcbiAqL1xuY29uc3QgICAgICAgIEZhcj0oZmFyTmFtZSxyZW1vdGFibGU9dW5kZWZpbmVkKT0+e1xuY29uc3Qgcj1yZW1vdGFibGU9PT11bmRlZmluZWQ/LyoqIEB0eXBlIHtUfSAqL3t9OnJlbW90YWJsZTtcbmlmKHR5cGVvZiByPT09J29iamVjdCcmJiEoR0VUX01FVEhPRF9OQU1FUyBpbiByKSl7XG4vKiBUaGlzIHRlc3QgZXhjbHVkZXMgZmFyIGZ1bmN0aW9ucywgc2luY2Ugd2UgY3VycmVudGx5IGNvbnNpZGVyIHRoZW0qL1xuLyogdG8gb25seSBoYXZlIGEgY2FsbC1iZWhhdmlvciwgd2l0aCBubyBjYWxsYWJsZSBtZXRob2RzLiovXG4vKiBCZXdhcmU6IE11dGF0ZXMgdGhlIGlucHV0IGFyZ3VtZW50ISBCdXQgYFJlbW90YWJsZWAqL1xuLyogKiByZXF1aXJlcyB0aGUgb2JqZWN0IHRvIGJlIG11dGFibGUqL1xuLyogKiBkb2VzIGZ1cnRoZXIgbXV0YXRpb25zLCovXG4vKiAqIGhhcmRlbnMgdGhlIG11dGF0ZWQgb2JqZWN0IGJlZm9yZSByZXR1cm5pbmcgaXQuKi9cbi8qIHNvIHRoaXMgbXV0YXRpb24gaXMgbm90IHVucHJlY2VkZW50ZWQuIEJ1dCBpdCBpcyBzdXJwcmlzaW5nISovXG5PYmplY3QuZGVmaW5lUHJvcGVydHkocixHRVRfTUVUSE9EX05BTUVTLGdldE1ldGhvZE5hbWVzRGVzY3JpcHRvcik7XG4gfVxucmV0dXJuIFJlbW90YWJsZSggYEFsbGVnZWQ6ICR7ZmFyTmFtZX1gLHVuZGVmaW5lZCxyKTtcbiB9OyRozY9fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gRlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0ge0Z9IGZ1bmNcbiAqIEByZXR1cm5zIHtGICYgUmVtb3RhYmxlT2JqZWN0ICYgUmVtb3RhYmxlQnJhbmQ8e30sIEY+fVxuICovXG5jb25zdCAgICAgICAgVG9GYXJGdW5jdGlvbj0oZmFyTmFtZSxmdW5jKT0+e1xuaWYoZ2V0SW50ZXJmYWNlT2YoZnVuYykhPT11bmRlZmluZWQpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjaGVja2VkIGNhc3QqL1xucmV0dXJuIGZ1bmM7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBjb3VsZCBiZSBkaWZmZXJlbnQgc3VidHlwZSovXG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRozY9fb25jZS5Ub0ZhckZ1bmN0aW9uKFRvRmFyRnVuY3Rpb24pO1xuaGFyZGVuKFRvRmFyRnVuY3Rpb24pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUmVtb3RhYmxlIjpbIlJlbW90YWJsZSJdLCJHRVRfTUVUSE9EX05BTUVTIjpbIkdFVF9NRVRIT0RfTkFNRVMiXSwiRmFyIjpbIkZhciJdLCJUb0ZhckZ1bmN0aW9uIjpbIlRvRmFyRnVuY3Rpb24iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGVoiOh4FAAAeBQAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIl0sImV4cG9ydHMiOlsibWFrZVRhZ2dlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLFBBU1NfU1RZTEUsYXNzZXJ0UGFzc2FibGU7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBUXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQXG4gKiBAcGFyYW0ge1R9IHRhZ1xuICogQHBhcmFtIHtQfSBwYXlsb2FkXG4gKiBAcmV0dXJucyB7SU1QT1JUKCcuL3R5cGVzLmpzJykuQ29weVRhZ2dlZDxULFA+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRozY9fb25jZS5tYWtlVGFnZ2VkKG1ha2VUYWdnZWQpO1xuaGFyZGVuKG1ha2VUYWdnZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRhZ2dlZCI6WyJtYWtlVGFnZ2VkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiQ1giLCJQQVNTX1NUWUxFIiwiYXNzZXJ0Q2hlY2tlciIsImNhbkJlTWV0aG9kIiwiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCIsImNoZWNrUGFzc1N0eWxlIiwiY2hlY2tUYWdSZWNvcmQiLCJnZXRPd25EYXRhRGVzY3JpcHRvciIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IsXG5nZXRQcm90b3R5cGVPZixcbmhhc093blByb3BlcnR5Om9iamVjdEhhc093blByb3BlcnR5LFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcbmNvbnN0e2FwcGx5fT1SZWZsZWN0O1xuY29uc3R7dG9TdHJpbmdUYWc6dG9TdHJpbmdUYWdTeW1ib2x9PVN5bWJvbDtcblxuY29uc3QgdHlwZWRBcnJheVByb3RvdHlwZT1nZXRQcm90b3R5cGVPZihVaW50OEFycmF5LnByb3RvdHlwZSk7XG5jb25zdCB0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjPWdldE93blByb3BlcnR5RGVzY3JpcHRvcihcbnR5cGVkQXJyYXlQcm90b3R5cGUsXG50b1N0cmluZ1RhZ1N5bWJvbCk7XG5cbmFzc2VydCh0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjKTtcbmNvbnN0IGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZz10eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjLmdldDtcbmFzc2VydCh0eXBlb2YgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPT09J2Z1bmN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBoYXNPd25Qcm9wZXJ0eU9mPShvYmoscHJvcCk9PlxuYXBwbHkob2JqZWN0SGFzT3duUHJvcGVydHksb2JqLFtwcm9wXSk7JGjNj19vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbi8qIFRPRE8gdHJ5IHR5cGluZyB0aGlzOyBgPT4gdmFsIGlzIHt9IHRvbyBuYXJyb3csIGltcGxpZXMgbm8gcHJvcGVydGllcyovXG5jb25zdCAgICAgICAgaXNPYmplY3Q9KHZhbCk9Pk9iamVjdCh2YWwpPT09dmFsOyRozY9fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRozY9fb25jZS5pc1R5cGVkQXJyYXkoaXNUeXBlZEFycmF5KTtcbmhhcmRlbihpc1R5cGVkQXJyYXkpO1xuXG5jb25zdCAgICAgICAgUEFTU19TVFlMRT1TeW1ib2wuZm9yKCdwYXNzU3R5bGUnKTtcblxuLyoqXG4gKiBGb3IgYSBmdW5jdGlvbiB0byBiZSBhIHZhbGlkIG1ldGhvZCwgaXQgbXVzdCBub3QgYmUgcGFzc2FibGUuXG4gKiBPdGhlcndpc2UsIHdlIHJpc2sgY29uZnVzaW5nIHBhc3MtYnktY29weSBkYXRhIGNhcnJ5aW5nXG4gKiBmYXIgZnVuY3Rpb25zIHdpdGggYXR0ZW1wdHMgYXQgZmFyIG9iamVjdHMgd2l0aCBtZXRob2RzLlxuICpcbiAqIFRPRE8gSEFaQVJEIEJlY2F1c2Ugd2UgY2hlY2sgdGhpcyBvbiB0aGUgd2F5IHRvIGhhcmRlbmluZyBhIHJlbW90YWJsZSxcbiAqIHdlIGNhbm5vdCB5ZXQgY2hlY2sgdGhhdCBgZnVuY2AgaXMgaGFyZGVuZWQuIEhvd2V2ZXIsIHdpdGhvdXRcbiAqIGRvaW5nIHNvLCBpdCdzIGluaGVyaXRhbmNlIG1pZ2h0IGNoYW5nZSBhZnRlciB0aGUgYFBBU1NfU1RZTEVgXG4gKiBjaGVjayBiZWxvdy5cbiAqXG4gKiBAcGFyYW0ge2FueX0gZnVuY1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaM2PX29uY2UuUEFTU19TVFlMRShQQVNTX1NUWUxFKTtcbmNvbnN0ICAgICAgICBjYW5CZU1ldGhvZD0oZnVuYyk9PlxudHlwZW9mIGZ1bmM9PT0nZnVuY3Rpb24nJiYhKFBBU1NfU1RZTEUgaW4gZnVuYyk7JGjNj19vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjNj19vbmNlLmFzc2VydENoZWNrZXIoYXNzZXJ0Q2hlY2tlcik7XG5oYXJkZW4oYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogUmV0dXJucyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIGZ1bmN0aW9uIHRvIGZhaWwgdGhlIHByb3ZpZGVkIENoZWNrZXIgd2l0aCBkZXRhaWxzLlxuICogVGhlIG5hbWUgbXVzdCBiZSBzaG9ydCBmb3IgZXJnb25vbWljIGlubGluZSB1c2UgYXMgaW46XG4gKiBgYGBcbiAqIHJldHVybiBjaGVja0NvbmRpdGlvbiguLi4pIHx8ICghIWNoZWNrICYmIENYKGNoZWNrKWAuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY29uc3QgICAgICAgIENYPShjaGVjayk9PntcbmNvbnN0IHJlamVjdD0oVCwuLi5zdWJzKT0+Y2hlY2soZmFsc2UsWChULC4uLnN1YnMpKTtcbnJldHVybiByZWplY3Q7XG4gfTskaM2PX29uY2UuQ1goQ1gpO1xuaGFyZGVuKENYKTtcblxuLyoqXG4gKiBWZXJpZmllcyB0aGUgcHJlc2VuY2UgYW5kIGVudW1lcmFiaWxpdHkgb2YgYW4gb3duIGRhdGEgcHJvcGVydHlcbiAqIGFuZCByZXR1cm5zIGl0cyBkZXNjcmlwdG9yLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BOYW1lXG4gKiBAcGFyYW0ge2Jvb2xlYW59IHNob3VsZEJlRW51bWVyYWJsZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7UHJvcGVydHlEZXNjcmlwdG9yfVxuICovXG5jb25zdCAgICAgICAgZ2V0T3duRGF0YURlc2NyaXB0b3I9KFxuY2FuZGlkYXRlLFxucHJvcE5hbWUsXG5zaG91bGRCZUVudW1lcmFibGUsXG5jaGVjayk9Plxue1xuY29uc3QgZGVzYz0vKiogQHR5cGUge1Byb3BlcnR5RGVzY3JpcHRvcn0gKi9cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcihjYW5kaWRhdGUscHJvcE5hbWUpO1xuXG5yZXR1cm4oZGVzYyE9PXVuZGVmaW5lZHx8XG4hIWNoZWNrJiZDWChjaGVjaykgYCR7cShwcm9wTmFtZSl9IHByb3BlcnR5IGV4cGVjdGVkOiAke2NhbmRpZGF0ZX1gKSYmKFxuaGFzT3duUHJvcGVydHlPZihkZXNjLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gYWNjZXNzb3IgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWApJiYoXG5zaG91bGRCZUVudW1lcmFibGU/XG5kZXNjLmVudW1lcmFibGV8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGAke3EocHJvcE5hbWUpfSBtdXN0IGJlIGFuIGVudW1lcmFibGUgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWA6XG4hZGVzYy5lbnVtZXJhYmxlfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCk/XG5kZXNjOlxuLyoqIEB0eXBlIHtQcm9wZXJ0eURlc2NyaXB0b3J9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi91bmRlZmluZWQ7XG4gfTskaM2PX29uY2UuZ2V0T3duRGF0YURlc2NyaXB0b3IoZ2V0T3duRGF0YURlc2NyaXB0b3IpO1xuaGFyZGVuKGdldE93bkRhdGFEZXNjcmlwdG9yKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IFRcbiAqIEBwYXJhbSB7SU1QT1JUKCcuL3R5cGVzLmpzJykuUGFzc1N0eWxlZDxhbnksIFQ+fSB0YWdSZWNvcmRcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgZ2V0VGFnPSh0YWdSZWNvcmQpPT50YWdSZWNvcmRbU3ltYm9sLnRvU3RyaW5nVGFnXTskaM2PX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmoscGFzc1N0eWxlLGV4cGVjdGVkUGFzc1N0eWxlLGNoZWNrKT0+e1xucmV0dXJuKFxucGFzc1N0eWxlPT09ZXhwZWN0ZWRQYXNzU3R5bGV8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYEV4cGVjdGVkICR7cShleHBlY3RlZFBhc3NTdHlsZSl9LCBub3QgJHtxKHBhc3NTdHlsZSl9OiAke29ian1gKTtcblxuIH07JGjNj19vbmNlLmNoZWNrUGFzc1N0eWxlKGNoZWNrUGFzc1N0eWxlKTtcbmhhcmRlbihjaGVja1Bhc3NTdHlsZSk7XG5cbmNvbnN0IG1ha2VDaGVja1RhZ1JlY29yZD0oY2hlY2tQcm90byk9Pntcbi8qKlxuICogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVkPGFueSwgYW55Pn0gdGFnUmVjb3JkXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gZXhwZWN0ZWRQYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQsZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNPYmplY3QodGFnUmVjb3JkKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkmJihcbmlzRnJvemVuKHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBIHRhZ1JlY29yZCBtdXN0IGJlIGZyb3plbjogJHt0YWdSZWNvcmR9YCkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBbiBhcnJheSBjYW5ub3QgYmUgYSB0YWdSZWNvcmQ6ICR7dGFnUmVjb3JkfWApJiZcbmNoZWNrUGFzc1N0eWxlKFxudGFnUmVjb3JkLFxuZ2V0T3duRGF0YURlc2NyaXB0b3IodGFnUmVjb3JkLFBBU1NfU1RZTEUsZmFsc2UsY2hlY2spLnZhbHVlLFxuZXhwZWN0ZWRQYXNzU3R5bGUsXG5jaGVjaykmJihcblxudHlwZW9mIGdldE93bkRhdGFEZXNjcmlwdG9yKHRhZ1JlY29yZCxTeW1ib2wudG9TdHJpbmdUYWcsZmFsc2UsY2hlY2spLlxudmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkmJlxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaM2PX29uY2UuY2hlY2tUYWdSZWNvcmQoY2hlY2tUYWdSZWNvcmQpO1xuXG5oYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuXG5jb25zdCAgICAgICAgY2hlY2tGdW5jdGlvblRhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbnByb3RvIT09bnVsbCYmZ2V0UHJvdG90eXBlT2YocHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuISFjaGVjayYmXG5jaGVjayhcbmZhbHNlLFxuWCBgRm9yIGZ1bmN0aW9ucywgYSB0YWdSZWNvcmQgbXVzdCBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlOiAke3ZhbH1gKSk7JGjNj19vbmNlLmNoZWNrRnVuY3Rpb25UYWdSZWNvcmQoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG5cblxuaGFyZGVuKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJDWCI6WyJDWCJdLCJnZXRPd25EYXRhRGVzY3JpcHRvciI6WyJnZXRPd25EYXRhRGVzY3JpcHRvciJdLCJnZXRUYWciOlsiZ2V0VGFnIl0sImNoZWNrUGFzc1N0eWxlIjpbImNoZWNrUGFzc1N0eWxlIl0sImNoZWNrVGFnUmVjb3JkIjpbImNoZWNrVGFnUmVjb3JkIl0sImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiOlsiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZU9mLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vY29weUFycmF5LmpzIiwiLi9jb3B5UmVjb3JkLmpzIiwiLi90YWdnZWQuanMiLCIuL2Vycm9yLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3N5bWJvbC5qcyIsIi4vc2FmZS1wcm9taXNlLmpzIiwiLi9zdHJpbmcuanMiXSwiZXhwb3J0cyI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCIsImFzc2VydFBhc3NhYmxlIiwiaXNQYXNzYWJsZSIsInBhc3NTdHlsZU9mIiwidG9QYXNzYWJsZUVycm9yIiwidG9UaHJvd2FibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgaXNQcm9taXNlLFgsRmFpbCxxLGFubm90YXRlRXJyb3IsbWFrZUVycm9yLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYyxjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcixnZXRFcnJvckNvbnN0cnVjdG9yLGlzRXJyb3JMaWtlLFJlbW90YWJsZUhlbHBlcixhc3NlcnRQYXNzYWJsZVN5bWJvbCxhc3NlcnRTYWZlUHJvbWlzZSxhc3NlcnRQYXNzYWJsZVN0cmluZzskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJhbm5vdGF0ZUVycm9yXCIsIFskaM2PX2EgPT4gKGFubm90YXRlRXJyb3IgPSAkaM2PX2EpXV0sW1wibWFrZUVycm9yXCIsIFskaM2PX2EgPT4gKG1ha2VFcnJvciA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImlzVHlwZWRBcnJheVwiLCBbJGjNj19hID0+IChpc1R5cGVkQXJyYXkgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjNj19hID0+IChDb3B5QXJyYXlIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL2NvcHlSZWNvcmQuanNcIiwgW1tcIkNvcHlSZWNvcmRIZWxwZXJcIiwgWyRozY9fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRozY9fYSldXV1dLFtcIi4vdGFnZ2VkLmpzXCIsIFtbXCJUYWdnZWRIZWxwZXJcIiwgWyRozY9fYSA9PiAoVGFnZ2VkSGVscGVyID0gJGjNj19hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRozY9fYSA9PiAoRXJyb3JIZWxwZXIgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2NcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCIuL3NhZmUtcHJvbWlzZS5qc1wiLCBbW1wiYXNzZXJ0U2FmZVByb21pc2VcIiwgWyRozY9fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaM2PX2EpXV1dXSxbXCIuL3N0cmluZy5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTdHJpbmdcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTdHJpbmcgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGVIZWxwZXJ9IGZyb20gJy4vaW50ZXJuYWwtdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7Q29weUFycmF5LCBDb3B5UmVjb3JkLCBDb3B5VGFnZ2VkLCBQYXNzYWJsZX0gZnJvbSAnLi90eXBlcy5qcycgKi9cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UHJpbWl0aXZlU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbi8qKiBAdHlwZWRlZiB7RXhjbHVkZTxQYXNzU3R5bGUsIFByaW1pdGl2ZVN0eWxlIHwgXCJwcm9taXNlXCI+fSBIZWxwZXJQYXNzU3R5bGUgKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzRnJvemVuLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsdmFsdWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVyc1xuICogQHJldHVybnMge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIFBhc3NTdHlsZUhlbHBlcj4gfVxuICovXG5cbmNvbnN0IG1ha2VIZWxwZXJUYWJsZT0ocGFzc1N0eWxlSGVscGVycyk9Pntcbi8qKiBAdHlwZSB7UmVjb3JkPEhlbHBlclBhc3NTdHlsZSwgYW55PiAmIHtfX3Byb3RvX186IG51bGx9fSAqL1xuY29uc3QgSGVscGVyVGFibGU9e1xuX19wcm90b19fOm51bGwsXG5jb3B5QXJyYXk6dW5kZWZpbmVkLFxuY29weVJlY29yZDp1bmRlZmluZWQsXG50YWdnZWQ6dW5kZWZpbmVkLFxuZXJyb3I6dW5kZWZpbmVkLFxucmVtb3RhYmxlOnVuZGVmaW5lZH07XG5cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5jb25zdHtzdHlsZU5hbWV9PWhlbHBlcjtcbnN0eWxlTmFtZSBpbiBIZWxwZXJUYWJsZXx8RmFpbCBgVW5yZWNvZ25pemVkIGhlbHBlcjogJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09PT11bmRlZmluZWR8fFxuRmFpbCBgY29uZmxpY3RpbmcgaGVscGVycyBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09aGVscGVyO1xuIH1cbmZvcihjb25zdCBzdHlsZU5hbWUgb2Ygb3duS2V5cyhIZWxwZXJUYWJsZSkpe1xuSGVscGVyVGFibGVbc3R5bGVOYW1lXSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBtaXNzaW5nIGhlbHBlciBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbiB9XG5cbnJldHVybiBoYXJkZW4oSGVscGVyVGFibGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVycyBUaGUgcGFzc1N0eWxlSGVscGVycyB0byByZWdpc3RlcixcbiAqIGluIHByaW9yaXR5IG9yZGVyLlxuICogTk9URSBUaGVzZSBtdXN0IGFsbCBiZSBcInRydXN0ZWRcIixcbiAqIGNvbXBsZXRlLCBhbmQgbm9uLWNvbGxpZGluZy4gYG1ha2VQYXNzU3R5bGVPZmAgbWF5ICphc3N1bWUqIHRoYXQgZWFjaCBoZWxwZXJcbiAqIGRvZXMgd2hhdCBpdCBpcyBzdXBwb3NlZCB0byBkby4gYG1ha2VQYXNzU3R5bGVPZmAgaXMgbm90IHRyeWluZyB0byBkZWZlbmRcbiAqIGl0c2VsZiBhZ2FpbnN0IG1hbGljaW91cyBoZWxwZXJzLCB0aG91Z2ggaXQgZG9lcyBkZWZlbmQgYWdhaW5zdCBzb21lXG4gKiBhY2NpZGVudHMuXG4gKiBAcmV0dXJucyB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IG1ha2VQYXNzU3R5bGVPZj0ocGFzc1N0eWxlSGVscGVycyk9PntcbmNvbnN0IEhlbHBlclRhYmxlPW1ha2VIZWxwZXJUYWJsZShwYXNzU3R5bGVIZWxwZXJzKTtcbmNvbnN0IHJlbW90YWJsZUhlbHBlcj1IZWxwZXJUYWJsZS5yZW1vdGFibGU7XG5cbi8qKlxuICogUHVyZWx5IGZvciBwZXJmb3JtYW5jZS4gSG93ZXZlciBpdCBpcyBtdXRhYmxlIHN0YXRpYyBzdGF0ZSwgYW5kXG4gKiBpdCBkb2VzIGhhdmUgc29tZSBvYnNlcnZhYmlsaXR5IG9uIHByb3hpZXMuIFRPRE8gbmVlZCB0byBhc3Nlc3NcbiAqIHdoZXRoZXIgdGhpcyBjcmVhdGVzIGEgc3RhdGljIGNvbW11bmljYXRpb25zIGNoYW5uZWwuXG4gKlxuICogcGFzc1N0eWxlT2YgZG9lcyBhIGZ1bGwgcmVjdXJzaXZlIHdhbGsgb2YgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBpbiBvcmRlciB0byB2YWxpZGF0ZSB0aGF0IHRoZXkgYXJlIGFjeWNsaWMuIEluIGFkZGl0aW9uXG4gKiBpdCBpcyB1c2VkIGJ5IG90aGVyIGFsZ29yaXRobXMgdG8gcmVjdXJzaXZlbHkgd2FsayB0aGVzZSBwYXNzLWJ5LWNvcHlcbiAqIHN0cnVjdHVyZXMsIHNvIHdpdGhvdXQgdGhpcyBjYWNoZSwgdGhlc2UgYWxnb3JpdGhtcyBjb3VsZCBiZVxuICogTyhOKioyKSBvciB3b3JzZS5cbiAqXG4gKiBAdHlwZSB7V2Vha01hcDxXZWFrS2V5LCBQYXNzU3R5bGU+fVxuICovXG5jb25zdCBwYXNzU3R5bGVNZW1vPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZU9mfVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgcGFzc1N0eWxlT2Y9KHBhc3NhYmxlKT0+e1xuLyogRXZlbiB3aGVuIGEgV2Vha1NldCBpcyBjb3JyZWN0LCB3aGVuIHRoZSBzZXQgaGFzIGEgc2hvcnRlciBsaWZldGltZSovXG4vKiB0aGFuIGl0cyBrZXlzLCB3ZSBwcmVmZXIgYSBTZXQgZHVlIHRvIGV4cGVjdGVkIGltcGxlbWVudGF0aW9uKi9cbi8qIHRyYWRlb2Zmcy4qL1xuY29uc3QgaW5Qcm9ncmVzcz1uZXcgU2V0KCk7XG5cbmNvbnN0IHBhc3NTdHlsZU9mUmVjdXI9KGlubmVyKT0+e1xuY29uc3QgaW5uZXJJc09iamVjdD1pc09iamVjdChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbmNvbnN0IGlubmVyU3R5bGU9cGFzc1N0eWxlTWVtby5nZXQoaW5uZXIpO1xuaWYoaW5uZXJTdHlsZSl7XG5yZXR1cm4gaW5uZXJTdHlsZTtcbiB9XG4haW5Qcm9ncmVzcy5oYXMoaW5uZXIpfHxcbkZhaWwgYFBhc3MtYnktY29weSBkYXRhIGNhbm5vdCBiZSBjeWNsaWMgJHtpbm5lcn1gO1xuaW5Qcm9ncmVzcy5hZGQoaW5uZXIpO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2ZJbnRlcm5hbChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbnBhc3NTdHlsZU1lbW8uc2V0KGlubmVyLHBhc3NTdHlsZSk7XG5pblByb2dyZXNzLmRlbGV0ZShpbm5lcik7XG4gfVxucmV0dXJuIHBhc3NTdHlsZTtcbiB9O1xuXG5jb25zdCBwYXNzU3R5bGVPZkludGVybmFsPShpbm5lcik9PntcbmNvbnN0IHR5cGVzdHI9dHlwZW9mIGlubmVyO1xuc3dpdGNoKHR5cGVzdHIpe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzpcbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gdHlwZXN0cjtcbiB9XG5jYXNlJ3N0cmluZyc6e1xuYXNzZXJ0UGFzc2FibGVTdHJpbmcoaW5uZXIpO1xucmV0dXJuJ3N0cmluZyc7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKGlubmVyKTtcbnJldHVybidzeW1ib2wnO1xuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihpbm5lcj09PW51bGwpe1xucmV0dXJuJ251bGwnO1xuIH1cbmlmKCFpc0Zyb3plbihpbm5lcikpe1xuYXNzZXJ0LmZhaWwoXG4vKiBUeXBlZEFycmF5cyBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgaW4gaGFyZGVuKCkqL1xuLyogYW5kIGEgY29ycmVzcG9uZGluZyBzcGVjaWFsIGVycm9yIG1lc3NhZ2UgaGVyZS4qL1xuaXNUeXBlZEFycmF5KGlubmVyKT9cblggYENhbm5vdCBwYXNzIG11dGFibGUgdHlwZWQgYXJyYXlzIGxpa2UgJHtpbm5lcn0uYDpcblggYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgKTtcblxuIH1cbmlmKGlzUHJvbWlzZShpbm5lcikpe1xuYXNzZXJ0U2FmZVByb21pc2UoaW5uZXIpO1xucmV0dXJuJ3Byb21pc2UnO1xuIH1cbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xuY29uc3QgcGFzc1N0eWxlVGFnPWlubmVyW1BBU1NfU1RZTEVdO1xuaWYocGFzc1N0eWxlVGFnIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YocGFzc1N0eWxlVGFnLCdzdHJpbmcnKTtcbmNvbnN0IGhlbHBlcj1IZWxwZXJUYWJsZVtwYXNzU3R5bGVUYWddO1xuaGVscGVyIT09dW5kZWZpbmVkfHxcbkZhaWwgYFVucmVjb2duaXplZCBQYXNzU3R5bGU6ICR7cShwYXNzU3R5bGVUYWcpfWA7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc1N0eWxlfSAqL3Bhc3NTdHlsZVRhZyk7XG4gfVxuZm9yKGNvbnN0IGhlbHBlciBvZiBwYXNzU3R5bGVIZWxwZXJzKXtcbmlmKGhlbHBlci5jYW5CZVZhbGlkKGlubmVyKSl7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gaGVscGVyLnN0eWxlTmFtZTtcbiB9XG4gfVxucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuY2FzZSdmdW5jdGlvbic6e1xuaXNGcm96ZW4oaW5uZXIpfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgO1xudHlwZW9mIGlubmVyLnRoZW4hPT0nZnVuY3Rpb24nfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1wcm9taXNlIHRoZW5hYmxlc2A7XG5yZW1vdGFibGVIZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4ncmVtb3RhYmxlJztcbiB9XG5kZWZhdWx0OntcbnRocm93IGFzc2VydC5mYWlsKFggYFVucmVjb2duaXplZCB0eXBlb2YgJHtxKHR5cGVzdHIpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTtcblxucmV0dXJuIHBhc3NTdHlsZU9mUmVjdXIocGFzc2FibGUpO1xuIH07XG5yZXR1cm4gaGFyZGVuKHBhc3NTdHlsZU9mKTtcbiB9O1xuXG5jb25zdCAgICAgICAgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2w9U3ltYm9sLmZvcignQGVuZG8gcGFzc1N0eWxlT2YnKTtcblxuLyoqXG4gKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2wgcHJvcGVydHkgb24gdGhlIGdsb2JhbCxcbiAqIHRoZW4gcHJlc3VtYWJseSBpdCB3YXMgZW5kb3dlZCBmb3IgdXMgYnkgbGl2ZXNsb3RzIHdpdGggYSBgcGFzc1N0eWxlT2ZgXG4gKiBmdW5jdGlvbiwgc28gd2Ugc2hvdWxkIHVzZSBhbmQgZXhwb3J0IHRoYXQgb25lIGluc3RlYWQuXG4gKiBPdGhlciBzb2Z0d2FyZSBtYXkgaGF2ZSBsZWZ0IGl0IGZvciB1cyBoZXJlLFxuICogYnV0IGl0IHdvdWxkIHJlcXVpcmUgd3JpdGUgYWNjZXNzIHRvIG91ciBnbG9iYWwsIG9yIHRoZSBhYmlsaXR5IHRvXG4gKiBwcm92aWRlIGVuZG93bWVudHMgdG8gb3VyIGdsb2JhbCwgYm90aCBvZiB3aGljaCBzZWVtcyBhZGVxdWF0ZSBhcyBhIHRlc3Qgb2ZcbiAqIHdoZXRoZXIgaXQgaXMgYXV0aG9yaXplZCB0byBzZXJ2ZSB0aGUgc2FtZSByb2xlIGFzIGxpdmVzbG90cy5cbiAqXG4gKiBOT1RFIEhBWkFSRDogVGhpcyB1c2UgYnkgbGl2ZXNsb3RzIGRvZXMgcmVseSBvbiBgcGFzc1N0eWxlT2ZgIGJlaW5nXG4gKiBkZXRlcm1pbmlzdGljLiBJZiBpdCBpcyBub3QsIHRoZW4gaW4gYSBsaXZlc2xvdC1saWtlIHZpcnR1YWxpemVkXG4gKiBlbnZpcm9ubWVudCwgaXQgY2FuIGJlIHVzZWQgdG8gZGV0ZWN0IEdDLlxuICpcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqLyRozY9fb25jZS5QYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbChQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCk7XG5jb25zdCAgICAgICAgcGFzc1N0eWxlT2Y9XG5nbG9iYWxUaGlzJiZnbG9iYWxUaGlzW1Bhc3NTdHlsZU9mRW5kb3dtZW50U3ltYm9sXXx8XG5tYWtlUGFzc1N0eWxlT2YoW1xuQ29weUFycmF5SGVscGVyLFxuQ29weVJlY29yZEhlbHBlcixcblRhZ2dlZEhlbHBlcixcbkVycm9ySGVscGVyLFxuUmVtb3RhYmxlSGVscGVyXSk7JGjNj19vbmNlLnBhc3NTdHlsZU9mKHBhc3NTdHlsZU9mKTtcblxuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGU9KHZhbCk9PntcbnBhc3NTdHlsZU9mKHZhbCk7LyogdGhyb3dzIGlmIHZhbCBpcyBub3QgYSBwYXNzYWJsZSovXG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcblxuLyoqXG4gKiBJcyBgc3BlY2ltZW5gIFBhc3NhYmxlPyBUaGlzIHJldHVybnMgdHJ1ZSBpZmYgYHBhc3NTdHlsZU9mKHNwZWNpbWVuKWBcbiAqIHJldHVybnMgYSBzdHJpbmcuIFRoaXMgcmV0dXJucyBgZmFsc2VgIGlmZiBgcGFzc1N0eWxlT2Yoc3BlY2ltZW4pYCB0aHJvd3MuXG4gKiBVbmRlciBubyBub3JtYWwgY2lyY3Vtc3RhbmNlIHNob3VsZCBgaXNQYXNzYWJsZShzcGVjaW1lbilgIHRocm93LlxuICpcbiAqIFRPRE8gRGVwcmVjYXRlIGFuZCB1bHRpbWF0ZWx5IGRlbGV0ZSBAYWdvcmljL2Jhc2Utem9uZSdzIGBpc1Bhc3NhYmxlJyBpblxuICogZmF2b3Igb2YgdGhpcyBvbmUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8yMDk2XG4gKlxuICogVE9ETyBpbXBsZW1lbnQgYW4gaXNQYXNzYWJsZSB0aGF0IGRvZXMgbm90IHJlbHkgb24gdHJ5L2NhdGNoLlxuICogVGhpcyBpbXBsZW1lbnRhdGlvbiBpcyBqdXN0IGEgc3RhbmRpbiB1bnRpbCB0aGVuLlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMjA5NlxuICpcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHJldHVybnMge3NwZWNpbWVuIGlzIFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgaXNQYXNzYWJsZT0oc3BlY2ltZW4pPT57XG50cnl7XG4vKiBJbiBmYWN0LCBpdCBuZXZlciByZXR1cm5zIHVuZGVmaW5lZC4gSXQgZWl0aGVyIHJldHVybnMgYSovXG4vKiBzdHJpbmcgb3IgdGhyb3dzLiovXG5yZXR1cm4gcGFzc1N0eWxlT2Yoc3BlY2ltZW4pIT09dW5kZWZpbmVkO1xuIH1jYXRjaChfKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfTskaM2PX29uY2UuaXNQYXNzYWJsZShpc1Bhc3NhYmxlKTtcbmhhcmRlbihpc1Bhc3NhYmxlKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc1Bhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2M9KG5hbWUsZGVzYyk9PlxuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MobmFtZSxkZXNjLHBhc3NTdHlsZU9mKTtcblxuLyoqXG4gKiBBZnRlciBoYXJkZW5pbmcsIGlmIGBlcnJgIGlzIGEgcGFzc2FibGUgZXJyb3IsIHJldHVybiBpdC5cbiAqXG4gKiBPdGhlcndpc2UsIHJldHVybiBhIG5ldyBwYXNzYWJsZSBlcnJvciB0aGF0IHByb3BhZ2F0ZXMgdGhlIGRpYWdub3N0aWNcbiAqIGluZm8gb2YgdGhlIG9yaWdpbmFsLCBhbmQgaXMgbGlua2VkIHRvIHRoZSBvcmlnaW5hbCBhcyBhIG5vdGUuXG4gKlxuICogVE9ETyBBZG9wdCBhIG1vcmUgZmxleGlibGUgbm90aW9uIG9mIHBhc3NhYmxlIGVycm9yLCBpbiB3aGljaFxuICogYSBwYXNzYWJsZSBlcnJvciBjYW4gY29udGFpbiBvdGhlciBvd24gZGF0YSBwcm9wZXJ0aWVzIHdpdGhcbiAqIHRocm93YWJsZSB2YWx1ZXMuXG4gKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0ICAgICAgICB0b1Bhc3NhYmxlRXJyb3I9KGVycik9PntcbmhhcmRlbihlcnIpO1xuaWYoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mKSl7XG5yZXR1cm4gZXJyO1xuIH1cbmNvbnN0e25hbWUsbWVzc2FnZX09ZXJyO1xuY29uc3R7Y2F1c2U6Y2F1c2VEZXNjLGVycm9yczplcnJvcnNEZXNjfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoZXJyKTtcbmxldCBjYXVzZTtcbmxldCBlcnJvcnM7XG5pZihjYXVzZURlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnY2F1c2UnLGNhdXNlRGVzYykpe1xuY2F1c2U9Y2F1c2VEZXNjLnZhbHVlO1xuIH1cbmlmKGVycm9yc0Rlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnZXJyb3JzJyxlcnJvcnNEZXNjKSl7XG5lcnJvcnM9ZXJyb3JzRGVzYy52YWx1ZTtcbiB9XG5cbmNvbnN0IGVyckNvbnN0cnVjdG9yPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9bWFrZUVycm9yKCBgJHttZXNzYWdlfWAsZXJyQ29uc3RydWN0b3Ise1xuLyogQHRzLWlnbm9yZSBBc3N1bWluZyBjYXVzZSBpcyBFcnJvciB8IHVuZGVmaW5lZCovXG5jYXVzZSxcbmVycm9yc30pO1xuXG4vKiBTdGlsbCBuZWVkZWQsIGJlY2F1c2UgYG1ha2VFcnJvcmAgb25seSBkb2VzIGEgc2hhbGxvdyBmcmVlemUuKi9cbmhhcmRlbihuZXdFcnJvcik7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hbm5vdGF0ZUVycm9yKG5ld0Vycm9yLFggYGNvcGllZCBmcm9tIGVycm9yICR7ZXJyfWApO1xucGFzc1N0eWxlT2YobmV3RXJyb3IpPT09J2Vycm9yJ3x8XG5GYWlsIGBFeHBlY3RlZCAke25ld0Vycm9yfSB0byBiZSBhIHBhc3NhYmxlIGVycm9yYDtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRozY9fb25jZS50b1Bhc3NhYmxlRXJyb3IodG9QYXNzYWJsZUVycm9yKTtcbmhhcmRlbih0b1Bhc3NhYmxlRXJyb3IpO1xuXG4vKipcbiAqIEFmdGVyIGhhcmRlbmluZywgaWYgYHNwZWNpbWVuYCBpcyB0aHJvd2FibGUsIHJldHVybiBpdC5cbiAqIEEgc3BlY2ltZW4gaXMgdGhyb3dhYmxlIGlmZiBpdCBpcyBQYXNzYWJsZSBhbmQgY29udGFpbnMgbm8gUGFzc2FibGVDYXBzLFxuICogaS5lLiwgbm8gUmVtb3RhYmxlcyBvciBQcm9taXNlcy5cbiAqIElPVywgaWYgaXQgY29udGFpbnMgb25seSBjb3B5LWRhdGEgYW5kIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBPdGhlcndpc2UsIGlmIGBzcGVjaW1lbmAgaXMgKmFsbW9zdCogdGhyb3dhYmxlLCBmb3IgZXhhbXBsZSwgaXQgaXNcbiAqIGFuIGVycm9yIHRoYXQgY2FuIGJlIG1hZGUgdGhyb3dhYmxlIGJ5IGB0b1Bhc3NhYmxlRXJyb3JgLCB0aGVuXG4gKiByZXR1cm4gYHNwZWNpbWVuYCBjb252ZXJ0ZWQgdG8gYSB0aHJvd2FibGUuXG4gKlxuICogT3RoZXJ3aXNlLCB0aHJvdyBhIGRpYWdub3N0aWMgaW5kaWNhdGluZyBhIGZhaWx1cmUgdG8gY29lcmNlLlxuICpcbiAqIFRoaXMgaXMgaW4gc3VwcG9ydCBvZiB0aGUgZXhvIGJvdW5kYXJ5IHRocm93aW5nIG9ubHkgdGhyb3dhYmxlcywgdG8gZWFzZVxuICogc2VjdXJpdHkgcmV2aWV3LlxuICpcbiAqIFRPRE8gQWRvcHQgYSBtb3JlIGZsZXhpdGJsZSBub3Rpb24gb2YgdGhyb3dhYmxlLCBpbiB3aGljaFxuICogZGF0YSBjb250YWluZXJzIGNvbnRhaW5pbmcgbm9uLXBhc3NhYmxlIGVycm9ycyBjYW4gdGhlbXNlbHZlcyBiZSBjb2VyY2VkXG4gKiB0byB0aHJvd2FibGUgYnkgY29lcmNpbmcgdG8gYSBzaW1pbGFyIGNvbnRhaW5lcnMgY29udGFpbmluZ1xuICogdGhlIHJlc3VsdHMgb2YgY29lcmNpbmcgdGhvc2UgZXJyb3JzIHRvIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHNwZWNpbWVuXG4gKiBAcmV0dXJucyB7UGFzc2FibGU8bmV2ZXIsIEVycm9yPn1cbiAqL1xuY29uc3QgICAgICAgIHRvVGhyb3dhYmxlPShzcGVjaW1lbik9PntcbmhhcmRlbihzcGVjaW1lbik7XG5pZihpc0Vycm9yTGlrZShzcGVjaW1lbikpe1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcigvKiogQHR5cGUge0Vycm9yfSAqL3NwZWNpbWVuKTtcbiB9XG4vKiBOb3RlIHRoYXQgdGhpcyBzdGVwIHdpbGwgZmFpbCBpZiBgc3BlY2ltZW5gIHdvdWxkIGJlIGEgcGFzc2FibGUgY29udGFpbmVyKi9cbi8qIGV4Y2VwdCB0aGF0IGl0IGNvbnRhaW5zIG5vbi1wYXNzYWJsZSBlcnJvcnMgdGhhdCBjb3VsZCBiZSBjb252ZXJ0ZWQuKi9cbi8qIFRoaXMgd2lsbCBuZWVkIHRvIGJlIGZpeGVkIHRvIGRvIHRoZSBUT0RPIGFib3ZlLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2Yoc3BlY2ltZW4pO1xuaWYoaXNPYmplY3Qoc3BlY2ltZW4pKXtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5QXJyYXknOntcbmNvbnN0IGVsZW1lbnRzPS8qKiBAdHlwZSB7Q29weUFycmF5fSAqL3NwZWNpbWVuO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgZWxlbWVudHMpe1xuZWxlbWVudD09PXRvVGhyb3dhYmxlKGVsZW1lbnQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke2VsZW1lbnR9YDtcbiB9XG5icmVhaztcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmNvbnN0IHJlYz0vKiogQHR5cGUge0NvcHlSZWNvcmR9ICovc3BlY2ltZW47XG5mb3IoY29uc3QgdmFsIG9mIHZhbHVlcyhyZWMpKXtcbnZhbD09PXRvVGhyb3dhYmxlKHZhbCl8fFxuRmFpbCBgbmVzdGVkIHRvVGhyb3dhYmxlIGNvZXJjaW9uIG5vdCB5ZXQgc3VwcG9ydGVkICR7dmFsfWA7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRnPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi9zcGVjaW1lbjtcbmNvbnN0e3BheWxvYWR9PXRnO1xucGF5bG9hZD09PXRvVGhyb3dhYmxlKHBheWxvYWQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke3BheWxvYWR9YDtcbmJyZWFrO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVyPS8qKiBAdHlwZSB7RXJyb3J9ICovc3BlY2ltZW47XG5lcj09PXRvVGhyb3dhYmxlKGVyKXx8XG5GYWlsIGBuZXN0ZWQgdG9UaHJvd2FibGUgY29lcmNpb24gbm90IHlldCBzdXBwb3J0ZWQgJHtlcn1gO1xuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBBICR7cShwYXNzU3R5bGUpfSBpcyBub3QgdGhyb3dhYmxlOiAke3NwZWNpbWVufWA7XG4gfX1cblxuIH1cbnJldHVybiAoLyoqIEB0eXBlIHtQYXNzYWJsZTxuZXZlcixuZXZlcj59ICovc3BlY2ltZW4pO1xuIH07JGjNj19vbmNlLnRvVGhyb3dhYmxlKHRvVGhyb3dhYmxlKTtcbmhhcmRlbih0b1Rocm93YWJsZSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCJdLCJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdLCJpc1Bhc3NhYmxlIjpbImlzUGFzc2FibGUiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdLCJ0b1Rocm93YWJsZSI6WyJ0b1Rocm93YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACC5ALHEiIAABIiAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEsYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxoYXNPd25Qcm9wZXJ0eU9mLFBBU1NfU1RZTEUsY2hlY2tUYWdSZWNvcmQsY2hlY2tGdW5jdGlvblRhZ1JlY29yZCxpc09iamVjdCxnZXRUYWcsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjNj19hID0+IChjaGVja1RhZ1JlY29yZCA9ICRozY9fYSldXSxbXCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQgPSAkaM2PX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRozY9fYSA9PiAoaXNPYmplY3QgPSAkaM2PX2EpXV0sW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDaGVja2VyfSBmcm9tICcuL3R5cGVzLmpzJ1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlYywgUGFzc1N0eWxlZH0gZnJvbSAnLi90eXBlcy5qcydcbiAqIEBpbXBvcnQge1Bhc3NTdHlsZUhlbHBlcn0gZnJvbSAnLi9pbnRlcm5hbC10eXBlcy5qcydcbiAqIEBpbXBvcnQge1JlbW90YWJsZU9iamVjdCBhcyBSZW1vdGFibGV9IGZyb20gJy4vdHlwZXMuanMnXG4gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZSxcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICovXG5jb25zdCBjaGVja0lmYWNlPShpZmFjZSxjaGVjayk9PntcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRm9yIG5vdywgaW50ZXJmYWNlICR7aWZhY2V9IG11c3QgYmUgYSBzdHJpbmc7IHVuaW1wbGVtZW50ZWRgKSYmKFxuaWZhY2U9PT0nUmVtb3RhYmxlJ3x8XG5pZmFjZS5zdGFydHNXaXRoKCdBbGxlZ2VkOiAnKXx8XG5pZmFjZS5zdGFydHNXaXRoKCdEZWJ1Z05hbWU6ICcpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGb3Igbm93LCBpZmFjZSAke3EoXG5pZmFjZSlcbiB9IG11c3QgYmUgXCJSZW1vdGFibGVcIiBvciBiZWdpbiB3aXRoIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiOyB1bmltcGxlbWVudGVkYCkpO1xuXG4gfTtcblxuLyoqXG4gKiBBbiBgaWZhY2VgIG11c3QgYmUgcHVyZS4gUmlnaHQgbm93IGl0IG11c3QgYmUgYSBzdHJpbmcsIHdoaWNoIGlzIHB1cmUuXG4gKiBMYXRlciB3ZSBleHBlY3QgdG8gaW5jbHVkZSBzb21lIG90aGVyIHZhbHVlcyB0aGF0IHF1YWxpZnkgYXMgYFB1cmVEYXRhYCxcbiAqIHdoaWNoIGlzIGEgcGFzcy1ieS1jb3B5IHN1cGVyc3RydWN0dXJlIGVuZGluZyBvbmx5IGluIHByaW1pdGl2ZXMgb3JcbiAqIGVtcHR5IHBhc3MtYnktY29weSBjb21wb3NpdGVzLiBObyByZW1vdGFibGVzLCBwcm9taXNlcywgb3IgZXJyb3JzLlxuICogV2UgKmFzc3VtZSogZm9yIG5vdyB0aGF0IHRoZSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgY29udGFpbnMgbm9cbiAqIHByb3hpZXMuXG4gKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0SWZhY2U9KGlmYWNlKT0+Y2hlY2tJZmFjZShpZmFjZSxhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmlzT2JqZWN0KG9yaWdpbmFsKXx8XG5GYWlsIGBSZW1vdGFibGVzIG11c3QgYmUgb2JqZWN0cyBvciBmdW5jdGlvbnM6ICR7b3JpZ2luYWx9YDtcblxuLyogQSB2YWxpZCByZW1vdGFibGUgb2JqZWN0IG11c3QgaW5oZXJpdCBmcm9tIGEgXCJ0YWcgcmVjb3JkXCIgLS0gYSovXG4vKiBwbGFpbi1vYmplY3QgcHJvdG90eXBlIGNvbnNpc3Rpbmcgb2Ygb25seSovXG4vKiBhIGBQQVNTX1NUWUxFYCBwcm9wZXJ0eSB3aXRoIHZhbHVlIFwicmVtb3RhYmxlXCIgYW5kIGEgc3VpdGFibGUgYFN5bWJvbC50b1N0cmluZ1RhZ2AqL1xuLyogcHJvcGVydHkuIFRoZSByZW1vdGFibGUgY291bGQgaW5oZXJpdCBkaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLCBvciovXG4vKiBpdCBjb3VsZCBpbmhlcml0IGZyb20gYW5vdGhlciB2YWxpZCByZW1vdGFibGUsIHRoYXQgdGhlcmVmb3JlIGl0c2VsZiovXG4vKiBpbmhlcml0cyBkaXJlY3RseSBvciBpbmRpcmVjdGx5IGZyb20gc3VjaCBhIHRhZyByZWNvcmQuKi9cbi8qKi9cbi8qIFRPRE86IEl0IHdvdWxkIGJlIG5pY2UgdG8gdHlwZWRlZiB0aGlzIHNoYXBlLCBidXQgd2UgY2FuJ3QgZGVjbGFyZSBhIHR5cGUqL1xuLyogd2l0aCBQQVNTX1NUWUxFIGZyb20gSlNEb2MuKi9cbi8qKi9cbi8qIEB0eXBlIHt7IFtQQVNTX1NUWUxFXTogc3RyaW5nLCovXG4vKiBbU3ltYm9sLnRvU3RyaW5nVGFnXTogc3RyaW5nLCovXG4vKiB9fSovXG4vKiovXG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihvcmlnaW5hbCk7XG5pZihcbnByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbnByb3RvPT09bnVsbHx8XG5wcm90bz09PUZ1bmN0aW9uLnByb3RvdHlwZSlcbntcbnJldHVybihcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZW1vdGFibGVzIG11c3QgYmUgZXhwbGljaXRseSBkZWNsYXJlZDogJHtxKG9yaWdpbmFsKX1gKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gUmVtb3RhYmxlIFByb3RvICR7b3duS2V5cyhyZXN0RGVzY3MpfWApJiZcbmNoZWNrSWZhY2UoaWZhY2UsY2hlY2spKTtcblxuIH07XG5cbi8qKlxuICogS2VlcCBhIHdlYWsgc2V0IG9mIGNvbmZpcm1lZCByZW1vdGFibGVzIGZvciBtYXJzaGFsIHBlcmZvcm1hbmNlXG4gKiAod2l0aG91dCB3aGljaCB3ZSB3b3VsZCBpbmN1ciBhIHJlZHVuZGFudCB2ZXJpZmljYXRpb24gaW5cbiAqIGdldEludGVyZmFjZU9mKS5cbiAqIFdlIGRvbid0IHJlbWVtYmVyIHJlamVjdGlvbnMgYmVjYXVzZSB0aGV5IGFyZSBwb3NzaWJsZSB0byBjb3JyZWN0XG4gKiB3aXRoIGUuZy4gYGhhcmRlbmAuXG4gKlxuICogQHR5cGUge1dlYWtTZXQ8UmVtb3RhYmxlPn1cbiAqL1xuY29uc3QgY29uZmlybWVkUmVtb3RhYmxlcz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge3ZhbCBpcyBSZW1vdGFibGV9XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlPSh2YWwsY2hlY2spPT57XG5pZihjb25maXJtZWRSZW1vdGFibGVzLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybihcbiEhY2hlY2smJkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke3ZhbH1gKTtcblxuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIFNpbXBsZSBzZW1hbnRpY3MsIGp1c3QgdGVsbCB3aGF0IGludGVyZmFjZSBzcGVjIGEgUmVtb3RhYmxlIGhhcyxcbiAqIG9yIHVuZGVmaW5lZCBpZiBub3QgZGVlbWVkIHRvIGJlIGEgUmVtb3RhYmxlLlxuICpcbiAqIEB0eXBlIHt7XG4gKiA8VCBleHRlbmRzIHN0cmluZz4odmFsOiBQYXNzU3R5bGVkPGFueSwgVD4pOiBUO1xuICogKHZhbDogYW55KTogSW50ZXJmYWNlU3BlYyB8IHVuZGVmaW5lZDtcbiAqIH19XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbi8qIEB0cy1leHBlY3QtZXJyb3IgbmFycm93ZWQqL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5hcnJvd2VkKi9cbnJldHVybiBnZXRUYWcodmFsKTtcbiB9OyRozY9fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCB2YWxpZFR5cGU9XG4oaXNPYmplY3QoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tb2JqZWN0cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgYXJyYXlzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKTtcbmlmKCF2YWxpZFR5cGUpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xuaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdvYmplY3QnKXtcbi8qIEV2ZXJ5IG93biBwcm9wZXJ0eSAocmVnYXJkbGVzcyBvZiBlbnVtZXJhYmlsaXR5KSovXG4vKiBtdXN0IGhhdmUgYSBmdW5jdGlvbiB2YWx1ZS4qL1xucmV0dXJuIG93bktleXMoZGVzY3MpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4vKiBUeXBlY2FzdCBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG4oaGFzT3duUHJvcGVydHlPZihkZXNjc1svKiogQHR5cGUge3N0cmluZ30gKi9rZXldLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBjYW5ub3Qgc2VyaWFsaXplIFJlbW90YWJsZXMgd2l0aCBhY2Nlc3NvcnMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApJiYoXG5rZXk9PT1TeW1ib2wudG9TdHJpbmdUYWcmJmNoZWNrSWZhY2UoY2FuZGlkYXRlW2tleV0sY2hlY2spfHxcbihjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIG5vbi1tZXRob2RzIGxpa2UgJHtxKFxuU3RyaW5nKGtleSkpXG4gfSBpbiAke2NhbmRpZGF0ZX1gKSYmKFxua2V5IT09UEFTU19TVFlMRXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpO1xuXG4gfSk7XG4gfWVsc2UgaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdmdW5jdGlvbicpe1xuLyogRmFyIGZ1bmN0aW9ucyBjYW5ub3QgYmUgbWV0aG9kcywgYW5kIGNhbm5vdCBoYXZlIG1ldGhvZHMuKi9cbi8qIFRoZXkgbXVzdCBoYXZlIGV4YWN0bHkgZXhwZWN0ZWQgYC5uYW1lYCBhbmQgYC5sZW5ndGhgIHByb3BlcnRpZXMqL1xuY29uc3R7XG5uYW1lOm5hbWVEZXNjLFxubGVuZ3RoOmxlbmd0aERlc2MsXG4vKiBAdHMtaWdub3JlIFRTIGRvZXNuJ3QgbGlrZSBzeW1ib2xzIGFzIGNvbXB1dGVkIGluZGV4ZXM/PyovXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp0b1N0cmluZ1RhZ0Rlc2MsXG4uLi5yZXN0RGVzY3N9PVxuZGVzY3M7XG5jb25zdCByZXN0S2V5cz1vd25LZXlzKHJlc3REZXNjcyk7XG5yZXR1cm4oXG4obmFtZURlc2MmJnR5cGVvZiBuYW1lRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGYXIgZnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbiBsZW5ndGggbXVzdCBiZSBhIG51bWJlciwgaW4gJHtjYW5kaWRhdGV9YCkmJihcbnRvU3RyaW5nVGFnRGVzYz09PXVuZGVmaW5lZHx8XG4odHlwZW9mIHRvU3RyaW5nVGFnRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRmFyIGZ1bmN0aW9uIEBAdG9TdHJpbmdUYWcgbXVzdCBiZSBhIHN0cmluZywgaW4gJHtjYW5kaWRhdGV9YCkmJlxuY2hlY2tJZmFjZSh0b1N0cmluZ1RhZ0Rlc2MudmFsdWUsY2hlY2spKSYmKFxucmVzdEtleXMubGVuZ3RoPT09MHx8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSk7XG5cbiB9XG5yZXR1cm4hIWNoZWNrJiZDWChjaGVjaykgYHVucmVjb2duaXplZCB0eXBlb2YgJHtjYW5kaWRhdGV9YDtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaM2PX29uY2UuUmVtb3RhYmxlSGVscGVyKFJlbW90YWJsZUhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJZmFjZSI6WyJhc3NlcnRJZmFjZSJdLCJnZXRJbnRlcmZhY2VPZiI6WyJnZXRJbnRlcmZhY2VPZiJdLCJSZW1vdGFibGVIZWxwZXIiOlsiUmVtb3RhYmxlSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAARGFca6FAAAuhQAACsAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbImFzc2VydFNhZmVQcm9taXNlIiwiaXNTYWZlUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBpc1Byb21pc2UscSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2YsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wiaXNQcm9taXNlXCIsIFskaM2PX2EgPT4gKGlzUHJvbWlzZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge0NoZWNrZXJ9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2lzRnJvemVuLGdldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e3RvU3RyaW5nVGFnfT1TeW1ib2w7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCBrZXlzPW93bktleXMocHIpO1xuXG5pZihrZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG4vKipcbiAqIFRoaXMgZXhjbHVkZXMgdGhvc2Ugc3ltYm9sLW5hbWVkIG93biBwcm9wZXJ0aWVzIHRoYXQgYXJlIGFsc28gZm91bmQgb25cbiAqIGBQcm9taXNlLnByb3RvdHlwZWAsIHNvIHRoYXQgb3ZlcnJpZGVzIG9mIHRoZXNlIHByb3BlcnRpZXMgY2FuIGJlXG4gKiBleHBsaWNpdGx5IHRvbGVyYXRlZCBpZiB0aGV5IHBhc3MgdGhlIGBjaGVja1NhZmVPd25LZXlgIGNoZWNrIGJlbG93LlxuICogSW4gcGFydGljdWxhciwgd2Ugd2lzaCB0byB0b2xlcmF0ZVxuICogICAqIEFuIG92ZXJyaWRpbmcgYHRvU3RyaW5nVGFnYCBub24tZW51bWVyYWJsZSBkYXRhIHByb3BlcnR5XG4gKiAgICAgd2l0aCBhIHN0cmluZyB2YWx1ZS5cbiAqICAgKiBUaG9zZSBvd24gcHJvcGVydGllcyB0aGF0IG1pZ2h0IGJlIGFkZGVkIGJ5IE5vZGUncyBhc3luY19ob29rcy5cbiAqL1xuY29uc3QgdW5rbm93bktleXM9a2V5cy5maWx0ZXIoXG4oa2V5KT0+dHlwZW9mIGtleSE9PSdzeW1ib2wnfHwhaGFzT3duUHJvcGVydHlPZihQcm9taXNlLnByb3RvdHlwZSxrZXkpKTtcblxuXG5pZih1bmtub3duS2V5cy5sZW5ndGghPT0wKXtcbnJldHVybiBDWChcbmNoZWNrKVxuIGAke3ByfSAtIE11c3Qgbm90IGhhdmUgYW55IG93biBwcm9wZXJ0aWVzOiAke3EodW5rbm93bktleXMpfWA7XG4gfVxuXG4vKipcbiAqIEV4cGxpY2l0bHkgdG9sZXJhdGUgYSBgdG9TdHJpbmdUYWdgIHN5bWJvbC1uYW1lZCBub24tZW51bWVyYWJsZVxuICogZGF0YSBwcm9wZXJ0eSB3aG9zZSB2YWx1ZSBpcyBhIHN0cmluZy4gT3RoZXJ3aXNlLCB0b2xlcmF0ZSB0aG9zZVxuICogc3ltYm9sLW5hbWVkIHByb3BlcnRpZXMgdGhhdCBtaWdodCBiZSBhZGRlZCBieSBOb2RlSlMncyBhc3luY19ob29rcyxcbiAqIGlmIHRoZXkgb2JleSB0aGUgZXhwZWN0ZWQgc2FmZXR5IHByb3BlcnRpZXMuXG4gKlxuICogQXQgdGhlIHRpbWUgb2YgdGhpcyB3cml0aW5nLCBOb2RlJ3MgYXN5bmNfaG9va3MgY29udGFpbnMgdGhlXG4gKiBmb2xsb3dpbmcgY29kZSwgd2hpY2ggd2UgY2FuIHNhZmVseSB0b2xlcmF0ZVxuICpcbiAqIGBgYGpzXG4gKiBmdW5jdGlvbiBkZXN0cm95VHJhY2tpbmcocHJvbWlzZSwgcGFyZW50KSB7XG4gKiAgIHRyYWNrUHJvbWlzZShwcm9taXNlLCBwYXJlbnQpO1xuICogICBjb25zdCBhc3luY0lkID0gcHJvbWlzZVthc3luY19pZF9zeW1ib2xdO1xuICogICBjb25zdCBkZXN0cm95ZWQgPSB7IGRlc3Ryb3llZDogZmFsc2UgfTtcbiAqICAgcHJvbWlzZVtkZXN0cm95ZWRTeW1ib2xdID0gZGVzdHJveWVkO1xuICogICByZWdpc3RlckRlc3Ryb3lIb29rKHByb21pc2UsIGFzeW5jSWQsIGRlc3Ryb3llZCk7XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGtleVxuICovXG5jb25zdCBjaGVja1NhZmVPd25LZXk9KGtleSk9PntcbmlmKGtleT09PXRvU3RyaW5nVGFnKXtcbi8qIFRPRE8gc2hvdWxkIHdlIGFsc28gZW5mb3JjZSBhbnl0aGluZyBvbiB0aGUgY29udGVudHMgb2YgdGhlIHN0cmluZywqL1xuLyogc3VjaCBhcyB0aGF0IGl0IG11c3Qgc3RhcnQgd2l0aCBgJ1Byb21pc2UnYD8qL1xuY29uc3QgdGFnRGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IocHIsdG9TdHJpbmdUYWcpO1xuYXNzZXJ0KHRhZ0Rlc2MhPT11bmRlZmluZWQpO1xucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YodGFnRGVzYywndmFsdWUnKXx8XG5DWChcbmNoZWNrKVxuIGBPd24gQEB0b1N0cmluZ1RhZyBtdXN0IGJlIGEgZGF0YSBwcm9wZXJ0eSwgbm90IGFuIGFjY2Vzc29yOiAke3EodGFnRGVzYyl9YCkmJihcbnR5cGVvZiB0YWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxuQ1goXG5jaGVjaylcbiBgT3duIEBAdG9TdHJpbmdUYWcgdmFsdWUgbXVzdCBiZSBhIHN0cmluZzogJHtxKHRhZ0Rlc2MudmFsdWUpfWApJiYoXG4hdGFnRGVzYy5lbnVtZXJhYmxlfHxcbkNYKGNoZWNrKSBgT3duIEBAdG9TdHJpbmdUYWcgbXVzdCBub3QgYmUgZW51bWVyYWJsZTogJHtxKHRhZ0Rlc2MpfWApKTtcblxuIH1cbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBDWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YDtcbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVPd25LZXkpO1xuIH07XG5cbi8qKlxuICogVW5kZXIgSGFyZGVuZWQgSlMgYSBwcm9taXNlIGlzIFwic2FmZVwiIGlmIGl0cyBgdGhlbmAgbWV0aG9kIGNhbiBiZSBjYWxsZWRcbiAqIHN5bmNocm9ub3VzbHkgd2l0aG91dCBnaXZpbmcgdGhlIHByb21pc2UgYW4gb3Bwb3J0dW5pdHkgZm9yIGFcbiAqIHJlZW50cmFuY3kgYXR0YWNrIGR1cmluZyB0aGF0IGNhbGwuXG4gKlxuICogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85XG4gKiByYWlzZXMgdGhlIGlzc3VlIG9mIHRlc3RpbmcgdGhhdCBhIHNwZWNpbWVuIGlzIGEgc2FmZSBwcm9taXNlXG4gKiBzdWNoIHRoYXQgdGhlIHRlc3QgYWxzbyBkb2VzIG5vdCBnaXZlIHRoZSBzcGVjaW1lbiBhXG4gKiByZWVudHJhbmN5IG9wcG9ydHVuaXR5LiBUaGF0IGlzIHdlbGwgYmV5b25kIHRoZSBhbWJpdGlvbiBoZXJlLlxuICogVE9ETyBUaG91Z2ggaWYgd2UgZmlndXJlIG91dCBhIG5pY2Ugc29sdXRpb24sIGl0IG1pZ2h0IGJlIGdvb2QgdG9cbiAqIHVzZSBpdCBoZXJlIGFzIHdlbGwuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tTYWZlUHJvbWlzZT0ocHIsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxDWChjaGVjaykgYCR7cHJ9IC0gTXVzdCBiZSBmcm96ZW5gKSYmKFxuaXNQcm9taXNlKHByKXx8Q1goY2hlY2spIGAke3ByfSAtIE11c3QgYmUgYSBwcm9taXNlYCkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbkNYKGNoZWNrKSBgJHtwcn0gLSBNdXN0IGluaGVyaXQgZnJvbSBQcm9taXNlLnByb3RvdHlwZTogJHtxKFxuZ2V0UHJvdG90eXBlT2YocHIpKVxuIH1gKSYmXG5jaGVja1Byb21pc2VPd25LZXlzKC8qKiBAdHlwZSB7UHJvbWlzZX0gKi9wcixjaGVjaykpO1xuXG4gfTtcbmhhcmRlbihjaGVja1NhZmVQcm9taXNlKTtcblxuLyoqXG4gKiBEZXRlcm1pbmUgaWYgdGhlIGFyZ3VtZW50IGlzIGEgUHJvbWlzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHByIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7cHIgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHByb21pc2VcbiAqL1xuY29uc3QgICAgICAgIGlzU2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwciwoeCk9PngpOyRozY9fb25jZS5pc1NhZmVQcm9taXNlKGlzU2FmZVByb21pc2UpO1xuaGFyZGVuKGlzU2FmZVByb21pc2UpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0U2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwcixhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNTYWZlUHJvbWlzZSI6WyJpc1NhZmVQcm9taXNlIl0sImFzc2VydFNhZmVQcm9taXNlIjpbImFzc2VydFNhZmVQcm9taXNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3RyaW5nLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vudi1vcHRpb25zIiwiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLEZhaWw7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoga25vdyBhYm91dGBpc1dlbGxGb3JtZWRgKi9cbmNvbnN0IGhhc1dlbGxGb3JtZWRTdHJpbmdNZXRob2Q9ISFTdHJpbmcucHJvdG90eXBlLmlzV2VsbEZvcm1lZDtcblxuLyoqXG4gKiBJcyB0aGUgYXJndW1lbnQgYSB3ZWxsLWZvcm1lZCBzdHJpbmc/XG4gKlxuICogVW5mb3J0dW5hdGVseSwgdGhlXG4gKiBbc3RhbmRhcmQgYnVpbHQtaW4gYFN0cmluZy5wcm90b3R5cGUuaXNXZWxsRm9ybWVkYF0oaHR0cHM6Ly9naXRodWIuY29tL3RjMzkvcHJvcG9zYWwtaXMtdXN2LXN0cmluZylcbiAqIGRvZXMgYSBUb1N0cmluZyBvbiBpdHMgaW5wdXQsIGNhdXNpbmcgaXQgdG8ganVkZ2Ugbm9uLXN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MgaWYgdGhleSBjb2VyY2UgdG8gYSB3ZWxsLWZvcm1lZCBzdHJpbmdzLiBUaGlzXG4gKiByZWNhcGl0dWxhdGVzIHRoZSBtaXN0YWtlIGluIGhhdmluZyB0aGUgZ2xvYmFsIGBpc05hTmAgY29lcmNlIGl0cyBpbnB1dHMsXG4gKiBjYXVzaW5nIGl0IHRvIGp1ZGdlIG5vbi1zdHJpbmcgdG8gYmUgTmFOIGlmIHRoZXkgY29lcmNlIHRvIE5hTi5cbiAqXG4gKiBUaGlzIGBpc1dlbGxGb3JtZWRTdHJpbmdgIGZ1bmN0aW9uIG9ubHkganVkZ2VzIHdlbGwtZm9ybWVkIHN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MuIEZvciBhbGwgbm9uLXN0cmluZ3MgaXQgcmV0dXJucyBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge3N0ciBpcyBzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBpc1dlbGxGb3JtZWRTdHJpbmc9aGFzV2VsbEZvcm1lZFN0cmluZ01ldGhvZD9cbihzdHIpPT50eXBlb2Ygc3RyPT09J3N0cmluZycmJnN0ci5pc1dlbGxGb3JtZWQoKTpcbihzdHIpPT57XG5pZih0eXBlb2Ygc3RyIT09J3N0cmluZycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmZvcihjb25zdCBjaCBvZiBzdHIpe1xuLyogVGhlIHN0cmluZyBpdGVyYXRvciBpdGVyYXRlcyBieSBVbmljb2RlIGNvZGUgcG9pbnQsIG5vdCovXG4vKiBVVEYxNiBjb2RlIHVuaXQuIEJ1dCBpZiBpdCBlbmNvdW50ZXJzIGFuIHVucGFpcmVkIHN1cnJvZ2F0ZSwqL1xuLyogaXQgd2lsbCBwcm9kdWNlIGl0LiovXG5jb25zdCBjcD0vKiogQHR5cGUge251bWJlcn0gKi9jaC5jb2RlUG9pbnRBdCgwKTtcbmlmKGNwPj0weGQ4MDAmJmNwPD0weGRmZmYpe1xuLyogQWxsIHN1cnJvZ2F0ZXMgYXJlIGluIHRoaXMgcmFuZ2UuIFRoZSBzdHJpbmcgaXRlcmF0b3Igb25seSovXG4vKiBwcm9kdWNlcyBhIGNoYXJhY3RlciBpbiB0aGlzIHJhbmdlIGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzLCovXG4vKiB3aGljaCBvbmx5IGhhcHBlbnMgaWYgdGhlIHN0cmluZyBpcyBub3Qgd2VsbC1mb3JtZWQuKi9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNXZWxsRm9ybWVkU3RyaW5nKGlzV2VsbEZvcm1lZFN0cmluZyk7XG5oYXJkZW4oaXNXZWxsRm9ybWVkU3RyaW5nKTtcblxuLyoqXG4gKiBSZXR1cm5zIG5vcm1hbGx5IHdoZW4gYGlzV2VsbEZvcm1lZFN0cmluZyhzdHIpYCB3b3VsZCByZXR1cm4gdHJ1ZS5cbiAqIFRocm93cyBhIGRpYWdub3N0aWMgZXJyb3Igd2hlbiBgaXNXZWxsRm9ybWVkU3RyaW5nKHN0cilgIHdvdWxkIHJldHVybiBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge2Fzc2VydHMgc3RyIGlzIHN0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFdlbGxGb3JtZWRTdHJpbmc9KHN0cik9PntcbmlzV2VsbEZvcm1lZFN0cmluZyhzdHIpfHxGYWlsIGBFeHBlY3RlZCB3ZWxsLWZvcm1lZCB1bmljb2RlIHN0cmluZzogJHtzdHJ9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRXZWxsRm9ybWVkU3RyaW5nKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuXG5jb25zdCBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEU9XG5nZXRFbnZpcm9ubWVudE9wdGlvbignT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFJywnZGlzYWJsZWQnLFtcbidlbmFibGVkJ10pPT09XG4nZW5hYmxlZCc7XG5cbi8qKlxuICogRm9yIG5vdyxcbiAqIGlmIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGVudmlyb25tZW50IG9wdGlvbiBpcyBgJ2VuYWJsZWQnYCxcbiAqIHRoZW4gYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBpcyB0aGUgc2FtZSBhcyBgYXNzZXJ0V2VsbEZvcm1lZFN0cmluZ2AuXG4gKiBPdGhlcndpc2UgYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBqdXN0IGFzc2VydHMgdGhhdCBgc3RyYCBpcyBhIHN0cmluZy5cbiAqXG4gKiBDdXJyZW50bHksIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGRlZmF1bHRzIHRvIGAnZGlzYWJsZWQnYFxuICogYmVjYXVzZSB3ZSBkbyBub3QgeWV0IGtub3cgdGhlIHBlcmZvcm1hbmNlIGltcGFjdC4gTGF0ZXIsIGlmIHdlIGRlY2lkZSB3ZVxuICogY2FuIGFmZm9yZCBpdCwgd2UnbGwgZmlyc3QgY2hhbmdlIHRoZSBkZWZhdWx0IHRvIGAnZW5hYmxlZCdgIGFuZCB1bHRpbWF0ZWx5XG4gKiByZW1vdmUgdGhlIHN3aXRjaCBhbHRvZ2V0aGVyLiBCZSBwcmVwYXJlZCBmb3IgdGhlc2UgY2hhbmdlcy5cbiAqXG4gKiBUT0RPIG9uY2UgdGhlIHN3aXRjaCBpcyByZW1vdmVkLCBzaW1wbGlmeSBgYXNzZXJ0UGFzc2FibGVTdHJpbmdgIHRvXG4gKiBzaW1wbHkgYmUgYGFzc2VydFdlbGxGb3JtZWRTdHJpbmdgLlxuICpcbiAqIEBwYXJhbSB7IHVua25vd24gfSBzdHJcbiAqIEByZXR1cm5zIHthc3NlcnRzIHN0ciBpcyBzdHJpbmcgfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTdHJpbmc9KHN0cik9PntcbnR5cGVvZiBzdHI9PT0nc3RyaW5nJ3x8RmFpbCBgRXhwZWN0ZWQgc3RyaW5nICR7c3RyfWA7XG4hT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFfHxhc3NlcnRXZWxsRm9ybWVkU3RyaW5nKHN0cik7XG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTdHJpbmcoYXNzZXJ0UGFzc2FibGVTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3RyaW5nKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzV2VsbEZvcm1lZFN0cmluZyI6WyJpc1dlbGxGb3JtZWRTdHJpbmciXSwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyI6WyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIl0sImFzc2VydFBhc3NhYmxlU3RyaW5nIjpbImFzc2VydFBhc3NhYmxlU3RyaW5nIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMs77KO4EgAAuBIAACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3ltYm9sLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjNj19vbmNlLmlzUGFzc2FibGVTeW1ib2woaXNQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oaXNQYXNzYWJsZVN5bWJvbCk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZVN5bWJvbD0oc3ltKT0+XG5pc1Bhc3NhYmxlU3ltYm9sKHN5bSl8fFxuRmFpbCBgT25seSByZWdpc3RlcmVkIHN5bWJvbHMgb3Igd2VsbC1rbm93biBzeW1ib2xzIGFyZSBwYXNzYWJsZTogJHtxKHN5bSl9YDskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTeW1ib2woYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3ltYm9sKTtcblxuLyoqXG4gKiBJZiBgc3ltYCBpcyBhIHBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGEgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzXG4gKiBzeW1ib2wuIElmIGBzeW1gIGlzIGEgbm9uLXBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGB1bmRlZmluZWRgLlxuICpcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuIFNpbmNlIHRoZSByZWdpc3RyYXRpb24gc3RyaW5nIG9mIGEgcmVnaXN0ZXJlZCBzeW1ib2wgY2FuIGJlIGFueVxuICogc3RyaW5nLCBpZiB3ZSBzaW1wbHkgdXNlZCB0aGF0IHRvIGlkZW50aWZ5IHRob3NlIHN5bWJvbHMsIHRoZXJlIHdvdWxkIG5vdFxuICogYmUgYW55IHJlbWFpbmluZyBzdHJpbmdzIGxlZnQgb3ZlciB0byBpZGVudGlmeSB0aGUgd2VsbC1rbm93biBzeW1ib2xzLlxuICogSW5zdGVhZCwgd2UgcmVzZXJ2ZSBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGBcIkBAXCJgIGZvciBwdXJwb3NlcyBvZiB0aGlzXG4gKiBlbmNvZGluZy4gV2UgaWRlbnRpZnkgYSB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiBieSBwcmVmaXhpbmcgdGhlIHByb3BlcnR5IG5hbWUgd2l0aCBgXCJAQFwiYCwgc3VjaCBhcyBgXCJAQGl0ZXJhdG9yXCJgLlxuICogRm9yIHJlZ2lzdGVyZWQgc3ltYm9scyB3aG9zZSBuYW1lIGhhcHBlbnMgdG8gYmVnaW4gd2l0aCBgXCJAQFwiYCwgc3VjaFxuICogYXMgYFN5bWJvbC5mb3IoJ0BAaXRlcmF0b3InKWAgb3IgYFN5bWJvbC5mb3IoJ0BAZm9vJylgLCB3ZSBpZGVudGlmeVxuICogdGhlbSBieSBwcmVmaXhpbmcgdGhlbSB3aXRoIGFuIGV4dHJhIGBcIkBAXCJgLCBzdWNoIGFzXG4gKiBgXCJAQEBAaXRlcmF0b3JcImAgb3IgYFwiQEBAQGZvb1wiYC4gKFRoaXMgaXMgdGhlIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmdcbiAqIHRlY2huaXF1ZS4pXG4gKlxuICogQHBhcmFtIHtzeW1ib2x9IHN5bVxuICogQHJldHVybnMge3N0cmluZz19XG4gKi9cbmNvbnN0ICAgICAgICBuYW1lRm9yUGFzc2FibGVTeW1ib2w9KHN5bSk9PntcbmNvbnN0IG5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYobmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gd2VsbEtub3duU3ltYm9sTmFtZXMuZ2V0KHN5bSk7XG4gfVxuaWYobmFtZS5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBgQEAke25hbWV9YDtcbiB9XG5yZXR1cm4gbmFtZTtcbiB9OyRozY9fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaM2PX29uY2UucGFzc2FibGVTeW1ib2xGb3JOYW1lKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG5oYXJkZW4ocGFzc2FibGVTeW1ib2xGb3JOYW1lKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUGFzc2FibGVTeW1ib2wiOlsiaXNQYXNzYWJsZVN5bWJvbCJdLCJhc3NlcnRQYXNzYWJsZVN5bWJvbCI6WyJhc3NlcnRQYXNzYWJsZVN5bWJvbCJdLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiOlsibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sInBhc3NhYmxlU3ltYm9sRm9yTmFtZSI6WyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADBplv5UIAACVCAAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90YWdnZWQuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlRhZ2dlZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxnZXRPd25EYXRhRGVzY3JpcHRvcixjaGVja1Bhc3NTdHlsZTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrVGFnUmVjb3JkID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXSxbXCJjaGVja1Bhc3NTdHlsZVwiLCBbJGjNj19hID0+IChjaGVja1Bhc3NTdHlsZSA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtJTVBPUlQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBUYWdnZWRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTondGFnZ2VkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuY2hlY2tQYXNzU3R5bGUoY2FuZGlkYXRlLGNhbmRpZGF0ZVtQQVNTX1NUWUxFXSwndGFnZ2VkJyxjaGVjayksXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNoZWNrVGFnUmVjb3JkKGNhbmRpZGF0ZSwndGFnZ2VkJyxhc3NlcnRDaGVja2VyKTtcblxuLyogVHlwZWNhc3RzIG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbmNvbnN0IHBhc3NTdHlsZUtleT0vKiogQHR5cGUge3Vua25vd259ICovUEFTU19TVFlMRTtcbmNvbnN0IHRhZ0tleT0vKiogQHR5cGUge3Vua25vd259ICovU3ltYm9sLnRvU3RyaW5nVGFnO1xuY29uc3R7XG4vKiBjaGVja1RhZ1JlY29yZCBhbHJlYWR5IHZlcmlmaWVkIFBBU1NfU1RZTEUgYW5kIFN5bWJvbC50b1N0cmluZ1RhZyBvd24gZGF0YSBwcm9wZXJ0aWVzLiovXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovcGFzc1N0eWxlS2V5XTpfcGFzc1N0eWxlRGVzYyxcblsvKiogQHR5cGUge3N0cmluZ30gKi90YWdLZXldOl9sYWJlbERlc2MsXG5wYXlsb2FkOl9wYXlsb2FkRGVzYywvKiB2YWx1ZSBjaGVja2VkIGJ5IHJlY3Vyc2l2ZSB3YWxrIGF0IHRoZSBlbmQqL1xuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg9PT0wfHxcbkZhaWwgYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiB0YWdnZWQgcmVjb3JkICR7b3duS2V5cyhyZXN0RGVzY3MpfWA7XG5cbi8qIFZhbGlkYXRlIHRoYXQgdGhlICdwYXlsb2FkJyBwcm9wZXJ0eSBpcyBvd24vZGF0YS9lbnVtZXJhYmxlKi9cbi8qIGFuZCBpdHMgYXNzb2NpYXRlZCB2YWx1ZSBpcyByZWN1cnNpdmVseSBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKS52YWx1ZSk7XG5cbiB9fSk7JGjNj19vbmNlLlRhZ2dlZEhlbHBlcihUYWdnZWRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKomXX/AsAAPwLAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEscGFzc1N0eWxlT2Y7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjNj19hID0+IChwYXNzU3R5bGVPZiA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoqIEBpbXBvcnQge0NvcHlBcnJheSwgQ29weVJlY29yZCwgUGFzc2FibGUsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHBhc3MtYnktY29weSBhcnJheSwgQUtBIGEgXCJjb3B5QXJyYXlcIlxuICogaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjNj19vbmNlLmlzQ29weUFycmF5KGlzQ29weUFycmF5KTtcbmhhcmRlbihpc0NvcHlBcnJheSk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBBS0EgYVxuICogXCJjb3B5UmVjb3JkXCIgaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaM2PX29uY2UuaXNSZWNvcmQoaXNSZWNvcmQpO1xuaGFyZGVuKGlzUmVjb3JkKTtcblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHJlbW90YWJsZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtyZW1vdGFibGUgaXMgUmVtb3RhYmxlT2JqZWN0fVxuICovXG5jb25zdCBpc1JlbW90YWJsZT0ocmVtb3RhYmxlKT0+cGFzc1N0eWxlT2YocmVtb3RhYmxlKT09PSdyZW1vdGFibGUnOyRozY9fb25jZS5pc1JlbW90YWJsZShpc1JlbW90YWJsZSk7XG5oYXJkZW4oaXNSZW1vdGFibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaM2PX29uY2UuYXNzZXJ0Q29weUFycmF5KGFzc2VydENvcHlBcnJheSk7XG5oYXJkZW4oYXNzZXJ0Q29weUFycmF5KTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuY29uc3QgYXNzZXJ0UmVjb3JkPShyZWNvcmQsb3B0TmFtZU9mUmVjb3JkPSdBbGxlZ2VkIHJlY29yZCcpPT57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVjb3JkKTtcbnBhc3NTdHlsZT09PSdjb3B5UmVjb3JkJ3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mUmVjb3JkKX0gJHtyZWNvcmR9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBub3QgJHtxKFxucGFzc1N0eWxlKVxuIH1gO1xuIH07JGjNj19vbmNlLmFzc2VydFJlY29yZChhc3NlcnRSZWNvcmQpO1xuaGFyZGVuKGFzc2VydFJlY29yZCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlbW90YWJsZVxuICogQHJldHVybnMge2Fzc2VydHMgcmVtb3RhYmxlIGlzIFJlbW90YWJsZU9iamVjdH1cbiAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRSZW1vdGFibGUoYXNzZXJ0UmVtb3RhYmxlKTtcbmhhcmRlbihhc3NlcnRSZW1vdGFibGUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5QXJyYXkiOlsiaXNDb3B5QXJyYXkiXSwiaXNSZWNvcmQiOlsiaXNSZWNvcmQiXSwiaXNSZW1vdGFibGUiOlsiaXNSZW1vdGFibGUiXSwiYXNzZXJ0Q29weUFycmF5IjpbImFzc2VydENvcHlBcnJheSJdLCJhc3NlcnRSZWNvcmQiOlsiYXNzZXJ0UmVjb3JkIl0sImFzc2VydFJlbW90YWJsZSI6WyJhc3NlcnRSZW1vdGFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA7PqD1JMJAACTCQAAIQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsIi4vc3JjL21lbW8tcmFjZS5qcyIsIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VQcm9taXNlS2l0IiwicmFjZVByb21pc2VzIl0sInJlZXhwb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0LG1lbW9SYWNlOyRozY9faW1wb3J0cyhbW1wiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNcIiwgW1tcIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdFwiLCBbJGjNj19hID0+IChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQgPSAkaM2PX2EpXV1dXSxbXCIuL3NyYy9tZW1vLXJhY2UuanNcIiwgW1tcIm1lbW9SYWNlXCIsIFskaM2PX2EgPT4gKG1lbW9SYWNlID0gJGjNj19hKV1dXV0sW1wiLi9zcmMvaXMtcHJvbWlzZS5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VQcm9taXNlS2l0LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlUHJvbWlzZUtpdFwifSk7JGjNj19vbmNlLm1ha2VQcm9taXNlS2l0KG1ha2VQcm9taXNlS2l0KTtPYmplY3QuZGVmaW5lUHJvcGVydHkocmFjZVByb21pc2VzLCAnbmFtZScsIHt2YWx1ZTogXCJyYWNlUHJvbWlzZXNcIn0pOyRozY9fb25jZS5yYWNlUHJvbWlzZXMocmFjZVByb21pc2VzKTsgICBcblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gKi9cbmNvbnN0IEJlc3RQaXBlbGluYWJsZVByb21pc2U9Z2xvYmFsVGhpcy5IYW5kbGVkUHJvbWlzZXx8UHJvbWlzZTtcblxuLyoqXG4gKiBtYWtlUHJvbWlzZUtpdCgpIGJ1aWxkcyBhIFByb21pc2Ugb2JqZWN0LCBhbmQgcmV0dXJucyBhIHJlY29yZFxuICogY29udGFpbmluZyB0aGUgcHJvbWlzZSBpdHNlbGYsIGFzIHdlbGwgYXMgc2VwYXJhdGUgZmFjZXRzIGZvciByZXNvbHZpbmdcbiAqIGFuZCByZWplY3RpbmcgaXQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtJTVBPUlQoJy4vc3JjL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPn1cbiAqL1xuZnVuY3Rpb24gICAgICAgIG1ha2VQcm9taXNlS2l0KCl7XG5jb25zdHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn09bWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCk7XG5cbmNvbnN0IHByb21pc2U9bmV3IEJlc3RQaXBlbGluYWJsZVByb21pc2UoZXhlY3V0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtwcm9taXNlLHJlc29sdmUscmVqZWN0fSk7XG4gfVxuaGFyZGVuKG1ha2VQcm9taXNlS2l0KTtcblxuLyogTkI6IEFub3RoZXIgaW1wbGVtZW50YXRpb24gZm9yIFByb21pc2UucmFjZSB3b3VsZCBiZSB0byB1c2UgdGhlIHJlbGVhc2luZyBleGVjdXRvciwqL1xuLyogSG93ZXZlciB3aGlsZSBpdCB3b3VsZCBubyBsb25nZXIgbGVhayB0aGUgcmFjZWQgcHJvbWlzZSBvYmplY3RzIHRoZW1zZWx2ZXMsIGl0IHdvdWxkKi9cbi8qIHN0aWxsIGxlYWsgcmVhY3Rpb25zIG9uIHRoZSBub24tcmVzb2x2ZWQgcHJvbWlzZXMgY29udGVuZGluZyBmb3IgdGhlIHJhY2UuKi9cblxuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5mdW5jdGlvbiAgICAgICAgcmFjZVByb21pc2VzKHZhbHVlcyl7XG5yZXR1cm4gaGFyZGVuKG1lbW9SYWNlLmNhbGwoQmVzdFBpcGVsaW5hYmxlUHJvbWlzZSx2YWx1ZXMpKTtcbiB9XG5oYXJkZW4ocmFjZVByb21pc2VzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlS2l0IjpbIm1ha2VQcm9taXNlS2l0Il0sInJhY2VQcm9taXNlcyI6WyJyYWNlUHJvbWlzZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvaXMtcHJvbWlzZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiaXNQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNQcm9taXNlLCAnbmFtZScsIHt2YWx1ZTogXCJpc1Byb21pc2VcIn0pOyRozY9fb25jZS5pc1Byb21pc2UoaXNQcm9taXNlKTsgICAvKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gbWF5YmVQcm9taXNlIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7bWF5YmVQcm9taXNlIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmZ1bmN0aW9uICAgICAgICBpc1Byb21pc2UobWF5YmVQcm9taXNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUobWF5YmVQcm9taXNlKT09PW1heWJlUHJvbWlzZTtcbiB9XG5oYXJkZW4oaXNQcm9taXNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJvbWlzZSI6WyJpc1Byb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAASLuyqBcTAAAXEwAAKQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtZW1vUmFjZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgLyogSW5pdGlhbCB2ZXJzaW9uIGF1dGhvcmVkIGJ5IEJyaWFuIEtpbTpcbmh0dHBzOi8vZ2l0aHViLmNvbS9ub2RlanMvbm9kZS9pc3N1ZXMvMTc0NjkjaXNzdWVjb21tZW50LTY4NTIxNjc3N1xuIFRoaXMgaXMgZnJlZSBhbmQgdW5lbmN1bWJlcmVkIHNvZnR3YXJlIHJlbGVhc2VkIGludG8gdGhlIHB1YmxpYyBkb21haW4uXG4gQW55b25lIGlzIGZyZWUgdG8gY29weSwgbW9kaWZ5LCBwdWJsaXNoLCB1c2UsIGNvbXBpbGUsIHNlbGwsIG9yXG5kaXN0cmlidXRlIHRoaXMgc29mdHdhcmUsIGVpdGhlciBpbiBzb3VyY2UgY29kZSBmb3JtIG9yIGFzIGEgY29tcGlsZWRcbmJpbmFyeSwgZm9yIGFueSBwdXJwb3NlLCBjb21tZXJjaWFsIG9yIG5vbi1jb21tZXJjaWFsLCBhbmQgYnkgYW55XG5tZWFucy5cbiBJbiBqdXJpc2RpY3Rpb25zIHRoYXQgcmVjb2duaXplIGNvcHlyaWdodCBsYXdzLCB0aGUgYXV0aG9yIG9yIGF1dGhvcnNcbm9mIHRoaXMgc29mdHdhcmUgZGVkaWNhdGUgYW55IGFuZCBhbGwgY29weXJpZ2h0IGludGVyZXN0IGluIHRoZVxuc29mdHdhcmUgdG8gdGhlIHB1YmxpYyBkb21haW4uIFdlIG1ha2UgdGhpcyBkZWRpY2F0aW9uIGZvciB0aGUgYmVuZWZpdFxub2YgdGhlIHB1YmxpYyBhdCBsYXJnZSBhbmQgdG8gdGhlIGRldHJpbWVudCBvZiBvdXIgaGVpcnMgYW5kXG5zdWNjZXNzb3JzLiBXZSBpbnRlbmQgdGhpcyBkZWRpY2F0aW9uIHRvIGJlIGFuIG92ZXJ0IGFjdCBvZlxucmVsaW5xdWlzaG1lbnQgaW4gcGVycGV0dWl0eSBvZiBhbGwgcHJlc2VudCBhbmQgZnV0dXJlIHJpZ2h0cyB0byB0aGlzXG5zb2Z0d2FyZSB1bmRlciBjb3B5cmlnaHQgbGF3LlxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsXG5FWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Zcbk1FUkNIQU5UQUJJTElUWSwgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC5cbklOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SXG5PVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSxcbkFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUlxuT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLlxuIEZvciBtb3JlIGluZm9ybWF0aW9uLCBwbGVhc2UgcmVmZXIgdG8gPGh0dHA6Ly91bmxpY2Vuc2Uub3JnLz5cbiovXG5cblxuXG5cblxuXG5cbmNvbnN0IGlzT2JqZWN0PSh2YWx1ZSk9Pk9iamVjdCh2YWx1ZSk9PT12YWx1ZTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgW1Q9YW55XVxuICogQHR5cGVkZWYge29iamVjdH0gRGVmZXJyZWRcbiAqIEBwcm9wZXJ0eSB7KHZhbHVlPzogSU1QT1JUKFwiLi90eXBlcy5qc1wiKS5FUmVmPFQ+ICkgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHByb3BlcnR5IHsoZXJyPzogYW55ICkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IG5ldmVyXG4gKiAgfCB7c2V0dGxlZDogZmFsc2UsIGRlZmVycmVkczogU2V0PERlZmVycmVkPn1cbiAqICB8IHtzZXR0bGVkOiB0cnVlLCBkZWZlcnJlZHM/OiB1bmRlZmluZWR9XG4gKiB9IFByb21pc2VNZW1vUmVjb3JkXG4gKi9cblxuLyogS2V5cyBhcmUgdGhlIHZhbHVlcyBwYXNzZWQgdG8gcmFjZSwgdmFsdWVzIGFyZSBhIHJlY29yZCBvZiBkYXRhIGNvbnRhaW5pbmcgYSovXG4vKiBzZXQgb2YgZGVmZXJyZWRzIGFuZCB3aGV0aGVyIHRoZSB2YWx1ZSBoYXMgc2V0dGxlZC4qL1xuLyoqIEB0eXBlIHtXZWFrTWFwPG9iamVjdCwgUHJvbWlzZU1lbW9SZWNvcmQ+fSAqL1xuY29uc3Qga25vd25Qcm9taXNlcz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZU1lbW9SZWNvcmQgfCB1bmRlZmluZWR9IHJlY29yZFxuICogQHJldHVybnMge1NldDxEZWZlcnJlZD59XG4gKi9cbmNvbnN0IG1hcmtTZXR0bGVkPShyZWNvcmQpPT57XG5pZighcmVjb3JkfHxyZWNvcmQuc2V0dGxlZCl7XG5yZXR1cm4gbmV3IFNldCgpO1xuIH1cblxuY29uc3R7ZGVmZXJyZWRzfT1yZWNvcmQ7XG5PYmplY3QuYXNzaWduKHJlY29yZCx7XG5kZWZlcnJlZHM6dW5kZWZpbmVkLFxuc2V0dGxlZDp0cnVlfSk7XG5cbk9iamVjdC5mcmVlemUocmVjb3JkKTtcbnJldHVybiBkZWZlcnJlZHM7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcmV0dXJucyB7UHJvbWlzZU1lbW9SZWNvcmR9XG4gKi9cbmNvbnN0IGdldE1lbW9SZWNvcmQ9KHZhbHVlKT0+e1xuaWYoIWlzT2JqZWN0KHZhbHVlKSl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIGEgcHJpbWl0aXZlLCBhdHRlbXB0aW5nIHRvIHVzZSBpdCBhcyBhIGtleSBpbiB0aGUqL1xuLyogd2Vha21hcCB3b3VsZCB0aHJvdyBhbiBlcnJvci4gTHVja2lseSwgaXQgaXMgc2FmZSB0byBjYWxsKi9cbi8qIGBQcm9taXNlLnJlc29sdmUoY29udGVuZGVyKS50aGVuYCBvbiBhIHByaW1pdGl2ZSB2YWx1ZSBtdWx0aXBsZSB0aW1lcyovXG4vKiBiZWNhdXNlIHRoZSBwcm9taXNlIGZ1bGZpbGxzIGltbWVkaWF0ZWx5LiBTbyB3ZSBmYWtlIGEgc2V0dGxlZCByZWNvcmQuKi9cbnJldHVybiBoYXJkZW4oe3NldHRsZWQ6dHJ1ZX0pO1xuIH1cblxubGV0IHJlY29yZD1rbm93blByb21pc2VzLmdldCh2YWx1ZSk7XG5cbmlmKCFyZWNvcmQpe1xucmVjb3JkPXtkZWZlcnJlZHM6bmV3IFNldCgpLHNldHRsZWQ6ZmFsc2V9O1xua25vd25Qcm9taXNlcy5zZXQodmFsdWUscmVjb3JkKTtcbi8qIFRoaXMgY2FsbCB0byBgdGhlbmAgaGFwcGVucyBvbmNlIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIHZhbHVlLiovXG5Qcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW4oXG4odmFsKT0+e1xuZm9yKGNvbnN0e3Jlc29sdmV9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZXNvbHZlKHZhbCk7XG4gfVxuIH0sXG4oZXJyKT0+e1xuZm9yKGNvbnN0e3JlamVjdH1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlamVjdChlcnIpO1xuIH1cbiB9KTtcblxuIH1cbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3R7cmFjZX09e1xuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHRlbXBsYXRlIHtQcm9taXNlQ29uc3RydWN0b3J9IFtQPVByb21pc2VDb25zdHJ1Y3Rvcl1cbiAqIEB0aGlzIHtQfVxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5yYWNlKHZhbHVlcyl7XG5sZXQgZGVmZXJyZWQ7XG4vKiogQHR5cGUge1suLi5UXX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgZmlsbGVkIGJ5IHRoZSBsb29wKi9cbmNvbnN0IGNhY2hlZFZhbHVlcz1bXTtcbmNvbnN0IEM9dGhpcztcbmNvbnN0IHJlc3VsdD1uZXcgQygocmVzb2x2ZSxyZWplY3QpPT57XG5kZWZlcnJlZD17cmVzb2x2ZSxyZWplY3R9O1xuZm9yKGNvbnN0IHZhbHVlIG9mIHZhbHVlcyl7XG5jYWNoZWRWYWx1ZXMucHVzaCh2YWx1ZSk7XG5jb25zdHtzZXR0bGVkLGRlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihzZXR0bGVkKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgc2V0dGxlZCAoaW5jbHVkaW5nIHByaW1pdGl2ZXMpLCBpdCBpcyBzYWZlKi9cbi8qIHRvIGNhbGwgYFByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbmAgb24gaXQuKi9cbkMucmVzb2x2ZSh2YWx1ZSkudGhlbihyZXNvbHZlLHJlamVjdCk7XG4gfWVsc2V7XG5kZWZlcnJlZHMuYWRkKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuXG4vKiBUaGUgZmluYWxseSBjYWxsYmFjayBleGVjdXRlcyB3aGVuIGFueSB2YWx1ZSBzZXR0bGVzLCBwcmV2ZW50aW5nIGFueSBvZiovXG4vKiB0aGUgdW5yZXNvbHZlZCB2YWx1ZXMgZnJvbSByZXRhaW5pbmcgYSByZWZlcmVuY2UgdG8gdGhlIHJlc29sdmVkIHZhbHVlLiovXG5yZXR1cm4gcmVzdWx0LmZpbmFsbHkoKCk9PntcbmZvcihjb25zdCB2YWx1ZSBvZiBjYWNoZWRWYWx1ZXMpe1xuY29uc3R7ZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKGRlZmVycmVkcyl7XG5kZWZlcnJlZHMuZGVsZXRlKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuIH19OyRozY9fb25jZS5yYWNlKHJhY2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWVtb1JhY2UiOlsicmFjZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACnhwxnegcAAHoHAAA0AAAAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAY2FsbGJhY2sgUHJvbWlzZUV4ZWN1dG9yIFRoZSBwcm9taXNlIGV4ZWN1dG9yXG4gKiBAcGFyYW0geyh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCkgYnVpbGRzIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyB3aGljaCBkcm9wIHJlZmVyZW5jZXNcbiAqIHRvIHRoZSByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgZ2F0aGVyZWQgZnJvbSBhbiBleGVjdXRvciB0byBiZSB1c2VkIHdpdGggYVxuICogcHJvbWlzZSBjb25zdHJ1Y3Rvci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1BpY2s8SU1QT1JUKCcuL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPiwgJ3Jlc29sdmUnIHwgJ3JlamVjdCc+ICYgeyBleGVjdXRvcjogUHJvbWlzZUV4ZWN1dG9yPFQ+fX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdD0oKT0+e1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKCh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZXNvbHZlO1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKChyZWFzb246IHVua25vd24pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVqZWN0O1xuXG4vKiogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+fSB2YWx1ZSAqL1xuY29uc3QgcmVzb2x2ZT0odmFsdWUpPT57XG5pZihpbnRlcm5hbFJlc29sdmUpe1xuaW50ZXJuYWxSZXNvbHZlKHZhbHVlKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT1udWxsKTtcbiB9XG4gfTtcblxuLyoqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uICovXG5jb25zdCByZWplY3Q9KHJlYXNvbik9PntcbmlmKGludGVybmFsUmVqZWN0KXtcbmludGVybmFsUmVqZWN0KHJlYXNvbik7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZWplY3Q9PT1udWxsKTtcbiB9XG4gfTtcblxuY29uc3QgZXhlY3V0b3I9KHJlcyxyZWopPT57XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09dW5kZWZpbmVkJiZpbnRlcm5hbFJlamVjdD09PXVuZGVmaW5lZCk7XG5pbnRlcm5hbFJlc29sdmU9cmVzO1xuaW50ZXJuYWxSZWplY3Q9cmVqO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfSk7XG4gfTskaM2PX29uY2UubWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG5oYXJkZW4obWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAC/O3Wf2BQAA9gUAAC0AAABAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy9kZW1vL3JhZy92YXRzL3VzZXIuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJidWlsZFJvb3RPYmplY3QiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgRSxGYXI7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaM2PX2EgPT4gKEUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJGYXJcIiwgWyRozY9fYSA9PiAoRmFyID0gJGjNj19hKV1dXV1dKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoYnVpbGRSb290T2JqZWN0LCAnbmFtZScsIHt2YWx1ZTogXCJidWlsZFJvb3RPYmplY3RcIn0pOyRozY9fb25jZS5idWlsZFJvb3RPYmplY3QoYnVpbGRSb290T2JqZWN0KTsgICBcblxuXG4vKipcbiAqIEJ1aWxkIGZ1bmN0aW9uIGZvciB0aGUgTExNIHRlc3QgdmF0LlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gX3ZhdFBvd2VycyAtIFNwZWNpYWwgcG93ZXJzIGdyYW50ZWQgdG8gdGhpcyB2YXQgKG5vdCB1c2VkIGhlcmUpLlxuICogQHBhcmFtIHt1bmtub3dufSBwYXJhbWV0ZXJzIC0gSW5pdGlhbGl6YXRpb24gcGFyYW1ldGVycyBmcm9tIHRoZSB2YXQncyBjb25maWcgb2JqZWN0LlxuICogQHBhcmFtIHt1bmtub3dufSBfYmFnZ2FnZSAtIFJvb3Qgb2YgdmF0J3MgcGVyc2lzdGVudCBzdGF0ZSAobm90IHVzZWQgaGVyZSkuXG4gKiBAcmV0dXJucyB7dW5rbm93bn0gVGhlIHJvb3Qgb2JqZWN0IGZvciB0aGUgbmV3IHZhdC5cbiAqL1xuZnVuY3Rpb24gICAgICAgIGJ1aWxkUm9vdE9iamVjdChfdmF0UG93ZXJzLHBhcmFtZXRlcnMsX2JhZ2dhZ2Upe1xuY29uc3QgcHJvbXB0PXBhcmFtZXRlcnM/LnByb21wdD8/IGBTYXkgaGVsbG8uYDtcbmNvbnN0e3ZlcmJvc2V9PXBhcmFtZXRlcnM7XG5cbnJldHVybiBGYXIoJ3Jvb3QnLHtcbiAgICAgIGFzeW5jIGJvb3RzdHJhcCh2YXRzKXtcbmlmKHZlcmJvc2Upe1xuY29uc29sZS5sb2coJ0Jvb3RzdHJhcCcpO1xuIH1cbmNvbnNvbGUubG9nKFtcbicnLFxuJy0tLS0tXFxuVVNFUjpcXG4tLS0tLScsXG5wcm9tcHQsXG4nLS0tLS0nLFxuJyddLlxuam9pbignXFxuXFxuJykpO1xuY29uc3QgcmVzcG9uc2U9RSh2YXRzLm9sbGFtYSkuY2hhdChwcm9tcHQpO1xuY29uc29sZS5sb2coW1xuJycsXG4nLS0tLVxcbkxMTTpcXG4tLS0tJyxcbmF3YWl0IHJlc3BvbnNlLFxuJy0tLS0nLFxuJyddLlxuam9pbignXFxuXFxuJykpO1xuIH19KTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImJ1aWxkUm9vdE9iamVjdCI6WyJidWlsZFJvb3RPYmplY3QiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAQIeAwoAAAAAAAAAAADKe4HZlTsAAJU7AAAUAAAAAAAAAAAAAACkgQAAAABjb21wYXJ0bWVudC1tYXAuanNvblBLAQIeAwoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAAAAAAAAAAACkgcc7AABAZW5kby9jb21tb24tdjEuMi44L29iamVjdC1tYXAuanNQSwECHgMKAAAAAAAAAAAAxRjnOpQBAACUAQAAIQAAAAAAAAAAAAAApIFDRgAAQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAF2blOoeEwAAHhMAACsAAAAAAAAAAAAAAKSBFkgAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanNQSwECHgMKAAAAAAAAAAAA54weVukMAADpDAAAHAAAAAAAAAAAAAAApIF9WwAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAAAAAAAAAAACkgaBoAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvRS5qc1BLAQIeAwoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAAAAAAAAAAACkgTKjAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvZXhwb3J0cy5qc1BLAQIeAwoAAAAAAAAAAABtsJ5smBEAAJgRAAAnAAAAAAAAAAAAAACkgcOkAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanNQSwECHgMKAAAAAAAAAAAAbfEwFqEWAAChFgAANQAAAAAAAAAAAAAApIGgtgAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNQSwECHgMKAAAAAAAAAAAAF4RTDHkDAAB5AwAAKQAAAAAAAAAAAAAApIGUzQAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL25vLXNoaW0uanNQSwECHgMKAAAAAAAAAAAAHrjny+0QAADtEAAALQAAAAAAAAAAAAAApIFU0QAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL3RyYWNrLXR1cm5zLmpzUEsBAh4DCgAAAAAAAAAAAD/w5zpWAgAAVgIAACMAAAAAAAAAAAAAAKSBjOIAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3V0aWxzLmpzUEsBAh4DCgAAAAAAAAAAALiBafB0BwAAdAcAAB0AAAAAAAAAAAAAAKSBI+UAAEBlbmRvL21hcnNoYWwtdjEuNi4yL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAAAAAAAAAAAAAKSB0uwAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1BLAQIeAwoAAAAAAAAAAAAxiq7kSjoAAEo6AAArAAAAAAAAAAAAAACkgeVcAQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzUEsBAh4DCgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAAAAAAAAAAAAAKSBeJcBAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qc1BLAQIeAwoAAAAAAAAAAABwTp8yYSwAAGEsAAAqAAAAAAAAAAAAAACkgW7TAQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvbWFyc2hhbC1qdXN0aW4uanNQSwECHgMKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAAAAAAAAAAAApIEXAAIAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzUEsBAh4DCgAAAAAAAAAAABOxXN6ZNwAAmTcAACMAAAAAAAAAAAAAAKSBfAcCAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzUEsBAh4DCgAAAAAAAAAAAGa7QcrbQQAA20EAACUAAAAAAAAAAAAAAKSBVj8CAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAAAAAAAAAAAApIF0gQIAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAGovdarWCwAA1gsAAB4AAAAAAAAAAAAAAKSB/YICAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAChKaq8PwoAAD8KAAAgAAAAAAAAAAAAAACkgQ+PAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAB5gH8MAwgAAAMIAAAoAAAAAAAAAAAAAACkgYyZAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvY29weUFycmF5LmpzUEsBAh4DCgAAAAAAAAAAAKx1kaFJCgAASQoAACkAAAAAAAAAAAAAAKSB1aECAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzUEsBAh4DCgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAAAAAAAAAAAAAKSBZawCAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9kZWVwbHlGdWxmaWxsZWQuanNQSwECHgMKAAAAAAAAAAAAURL94C4bAAAuGwAAJAAAAAAAAAAAAAAApIHVwQIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzUEsBAh4DCgAAAAAAAAAAALuYdZNnCAAAZwgAACsAAAAAAAAAAAAAAKSBRd0CAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAA3mPGmlwkAABcJAAAJwAAAAAAAAAAAAAApIH15QIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL21ha2UtZmFyLmpzUEsBAh4DCgAAAAAAAAAAABlaIjoeBQAAHgUAACkAAAAAAAAAAAAAAKSBlgoDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAAAAAAAAAAAAAKSB+w8DAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAAAAAAAAAAACkgWQsAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlT2YuanNQSwECHgMKAAAAAAAAAAAAguQCxxIiAAASIgAAKAAAAAAAAAAAAAAApIEkYwMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc1BLAQIeAwoAAAAAAAAAAAAERhXGuhQAALoUAAArAAAAAAAAAAAAAACkgXyFAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAAAAAAAAAAAAAKSBf5oDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9zdHJpbmcuanNQSwECHgMKAAAAAAAAAAAAyzvso7gSAAC4EgAAJQAAAAAAAAAAAAAApIHWqQMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3N5bWJvbC5qc1BLAQIeAwoAAAAAAAAAAAAMGmW/lQgAAJUIAAAlAAAAAAAAAAAAAACkgdG8AwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvdGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAAqiZdf8CwAA/AsAACkAAAAAAAAAAAAAAKSBqcUDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAAS6w5NKAQAASgEAACQAAAAAAAAAAAAAAKSB7NEDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAADs+oPUkwkAAJMJAAAhAAAAAAAAAAAAAACkgXjTAwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAAAAAAAAAAAApIFK3QMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9pcy1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAEi7sqgXEwAAFxMAACkAAAAAAAAAAAAAAKSBhuADAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzUEsBAh4DCgAAAAAAAAAAAKeHDGd6BwAAegcAADQAAAAAAAAAAAAAAKSB5PMDAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAAAAAAAAAAAApIGw+wMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAvzt1n9gUAAPYFAAAtAAAAAAAAAAAAAACkgT39AwBAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy9kZW1vL3JhZy92YXRzL3VzZXIuanNQSwUGAAAAAC0ALQDyDgAAfgMEAAAA","endoZipBase64Sha512":"55b4ea59fa5b63ae43ebefe066665276b724d6166b5fc31e18689370fa0f8baa9a23a58e9680551dfa136bee665ea6727537867a764ea1a191dbecd43aa6cd32"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js new file mode 100644 index 000000000..ec7d1555c --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -0,0 +1,38 @@ +import { E } from '@endo/eventual-send'; +import { Far } from '@endo/marshal'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(_vatPowers, parameters, _baggage) { + const prompt = parameters?.prompt ?? `Say hello.`; + const { verbose } = parameters; + + return Far('root', { + async bootstrap(vats) { + if (verbose) { + console.log('Bootstrap') + } + console.log([ + '', + '-----\nUSER:\n-----', + prompt, + '-----', + '', + ].join('\n\n')); + const response = E(vats.ollama).chat(prompt); + console.log([ + '', + '----\nLLM:\n----', + await response, + '----', + '', + ].join('\n\n')); + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/vats/wiki.bundle b/packages/nodejs/src/demo/rag/vats/wiki.bundle new file mode 100644 index 000000000..a44054c1e --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/wiki.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"b8c9f88d049eba666aeb7f824c707e2379046a81f6d450ae44bf74716ba6b4aa4d7de93773ccb5d7038ae405f77852542cfe60b67f4b4d0c41dd14e100b83627"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/wiki.js b/packages/nodejs/src/demo/rag/vats/wiki.js new file mode 100644 index 000000000..4eddb8e8f --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/wiki.js @@ -0,0 +1,29 @@ +import { Far } from '@endo/marshal'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} vatPowers.vectorStore - A vectorStore power. + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(vatPowers, parameters, _baggage) { + const { vectorStore } = vatPowers; + const { docs } = parameters; + + console.log('DOCS:', docs); + + const initVectorStoreP = vectorStore.addDocuments([...docs]); + + return Far('root', { + async retrieve(topic) { + await initVectorStoreP; + // Search for the most similar document + const result = await vectorStore.similaritySearch(topic, 1); + console.log('Retrieve got', result); + return result; + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt b/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt new file mode 100644 index 000000000..350b6d943 --- /dev/null +++ b/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt @@ -0,0 +1,61 @@ +{{short description|Term used in the study of access control systems}} +'''Ambient authority''' is a term used in the study of [[access control]] systems. + +== Definition == +A subject, such as a computer program, is said to be using ''ambient authority'' if it only needs to specify the names of the involved object(s) and the operation to be performed on them in order for a permitted action to succeed. +{{cite journal + | last1=Miller | first1=Mark S. + | last2=Yee | first2=Ka-Ping + | last3=Shapiro | first3=Jonathan + | title=Capability Myths Demolished + | year=2003 + | url=http://www.cs.umd.edu/~jkatz/security/downloads/capability-myths.pdf +}} +{{cite mailing list + |last = Donnelley + |first = Jed + |title = [cap-talk] ... enforcement - ambient authority - definition? + |mailing-list = cap-talk + |date = 6 October 2004 + |url = http://www.eros-os.org/pipermail/cap-talk/2004-October/002001.html + |access-date = June 28, 2012 + |archive-url = https://archive.today/20130414191435/http://www.eros-os.org/pipermail/cap-talk/2004-October/002001.html + |archive-date = 2013-04-14 + |url-status = dead +}} +{{cite mailing list + | last =Tribble | first =Dean + | title =Re: [e-lang] "Capability Myths Demolished" => ambient authority revisited + | mailing-list =e-lang + | date =5 December 2002 + | url =http://zesty.ca/zest/out/msg00139.html + | access-date =June 28, 2012 +}} + +In this definition, +* a "name" is any way of referring to an object that does not itself include authorising information, and could potentially be used by any subject; +* an action is "permitted" for a subject if there exists ''any'' request that that subject could make that would cause the action to be carried out. + +The authority is "ambient" in the sense that it exists in a broadly visible environment (often, but not necessarily a global environment) where any subject can request it by name. + +== Example == +For example, suppose a C program opens a file for read access by executing the call: + + open("filename", O_RDONLY, 0) + +The desired file is designated by its name on the filesystem, which does not by itself include authorising information, so the program is exercising ambient authority. + +== Uses == +When ambient authority is requested, permissions are granted or denied based on one or more global properties of the executing program, such as its ''identity'' or its ''role''. In such cases, the management of [[access control]] is handled separately from explicit communication to the executing program or [[Process (computing)|process]], through means such as [[access control list]]s associated with objects or through [[Role-Based Access Control]] mechanisms. The executing program has no means to [[reification (computer science)|reify]] the permissions that it was granted for a specific purpose as [[first-class value]]s. So, if the program should be able to access an object when acting on its own behalf but not when acting on behalf of one of its clients (or, on behalf of one client but not another), it has no way to express that intention. This inevitably leads to such programs being subject to the [[confused deputy problem]]. + +The term "ambient authority" is used primarily to contrast with [[capability-based security]] (including [[object-capability model]]s), in which executing programs receive permissions as they might receive data, as communicated [[first-class object]] references. This allows them to determine where the permissions came from, and thus avoid the [[Confused deputy problem]]. However, since there are additional requirements for a system to be considered a capability system besides avoiding ambient authority, "non-ambient authority system" is not just a synonym for "capability system". + +Ambient authority is the dominant form of access control in computer systems today. The ''user'' model of access control as used in Unix and in Windows systems is an ambient authority model because programs execute with the authorities of the ''user'' that started them. This not only means that executing programs are inevitably given more permissions (see [[Principle of least privilege]]) than they need for their task, but that they are unable to determine the source or the number and types of permission that they have.{{cite book |chapter=Capability Computing at LLNL |author=Jed Donnelley |date=May 4, 2005 |chapter-url=https://www.computer-history.info/Page4.dir/pages/LTSS.NLTSS.dir/pages/cap-livermore.html |access-date=2022-12-06 |title=Stories of the Development of Large Scale Scientific Computing at Lawrence Livermore National Laboratory; An Oral and Pictorial History |url=https://www.computer-history.info/ |editor=George A. Michael |editor-link=George Michael (computational physicist)}} A program executing under an ambient authority access control model has little option but to designate permissions and try to exercise them, hoping for the best. This property requires an excess of permissions to be granted to users or roles, in order for programs to execute without error. + +==References== +{{Reflist}} + +{{Object-capability security}} + +{{DEFAULTSORT:Ambient Authority}} +[[Category:Access control]] diff --git a/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt b/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt new file mode 100644 index 000000000..69c9328c4 --- /dev/null +++ b/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt @@ -0,0 +1,67 @@ +{{Short description|Computer security vulnerability}} +In [[information security]], a '''confused deputy''' is a [[computer program]] that is tricked by another program (with fewer privileges or less rights) into misusing its authority on the system. It is a specific type of [[privilege escalation]].{{Cite journal|last=Wu|first=Jianliang|last2=Cui|first2=Tingting|last3=Ban|first3=Tao|last4=Guo|first4=Shanqing|last5=Cui|first5=Lizhen|date=2015-09-10|title=PaddyFrog: systematically detecting confused deputy vulnerability in Android applications: PaddyFrog: systematically detecting confused deputy vulnerability in Android applications|url=https://onlinelibrary.wiley.com/doi/10.1002/sec.1179|journal=Security and Communication Networks|language=en|volume=8|issue=13|pages=2338–2349|doi=10.1002/sec.1179}} The '''confused deputy problem''' is often cited as an example of why [[capability-based security]] is important. + +[[Capability-based security|Capability systems]] protect against the confused deputy problem, whereas [[access-control list]]–based systems do not.{{cite web|url=http://waterken.sourceforge.net/aclsdont/|title=ACLs don't|work=sourceforge.net}} + +== Example == +In the original example of a confused deputy,{{cite web|title=The Confused Deputy (or why capabilities might have been invented)|url=http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html|url-status=dead|access-date=2003-12-31|archiveurl=https://web.archive.org/web/20031205034929/http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html|archivedate=2003-12-05}} there was a [[compiler]] program provided on a commercial [[Time-sharing|timesharing]] service. Users could run the compiler and optionally specify a filename where it would write debugging output, and the compiler would be able to write to that file if the user had permission to write there. + +The compiler also collected statistics about language feature usage. Those statistics were stored in a file called "(SYSX)STAT", in the directory "SYSX". To make this possible, the compiler program was given permission to write to files in SYSX. + +But there were other files in SYSX: in particular, the system's billing information was stored in a file "(SYSX)BILL". A user ran the compiler and named "(SYSX)BILL" as the desired debugging output file. + +This produced a confused deputy problem. The compiler made a request to the [[operating system]] to open (SYSX)BILL. Even though the user did not have access to that file, the compiler did, so the open succeeded. The compiler wrote the compilation output to the file (here "(SYSX)BILL") as normal, overwriting it, and the billing information was destroyed. + +=== The confused deputy === +In this example, the compiler program is the deputy because it is acting at the request of the user. The program is seen as 'confused' because it was tricked into overwriting the system's billing file. + +Whenever a program tries to access a file, the operating system needs to know two things: which file the program is asking for, and whether the program has permission to access the file. In the example, the file is designated by its name, “(SYSX)BILL”. The program receives the file name from the user, but does not know whether the user had permission to write the file. When the program opens the file, the system uses the program's permission, not the user's. When the file name was passed from the user to the program, the permission did not go along with it; the permission was increased by the system silently and automatically. + +It is not essential to the attack that the billing file be designated by a name represented as a string. The essential points are that: +* the designator for the file does not carry the full authority needed to access the file; +* the program's own permission to access the file is used implicitly. + +== Other examples == +[[File:Don Knotts Barney and the bullet Andy Griffith Show.jpg|thumb|Prototypical confused deputy [[Barney Fife]]]] +A [[cross-site request forgery]] (CSRF) is an example of a confused deputy attack that uses the [[web browser]] to perform sensitive actions against a web application. A common form of this attack occurs when a web application uses a cookie to authenticate all requests transmitted by a browser. Using [[JavaScript]], an attacker can force a browser into transmitting authenticated [[HTTP]] requests. + +The [[Samy (computer worm)|Samy computer worm]] used [[cross-site scripting]] (XSS) to turn the browser's authenticated MySpace session into a confused deputy. Using XSS the worm forced the browser into posting an executable copy of the worm as a MySpace message which was then viewed and executed by friends of the infected user. + +[[Clickjacking]] is an attack where the user acts as the confused deputy. In this attack a user thinks they are harmlessly browsing a website (an attacker-controlled website) but they are in fact tricked into performing sensitive actions on another website.{{cite web|url=http://waterken.sourceforge.net/clickjacking/|title=clickjacking: The Confused Deputy rides again!|work=sourceforge.net}} + +An [[FTP bounce attack]] can allow an attacker to connect indirectly to [[Transmission Control Protocol|TCP]] [[TCP ports|ports]] to which the attacker's machine has no access, using a remote [[FTP]] server as the confused deputy. + +Another example relates to [[personal firewall]] software. It can restrict Internet access for specific applications. Some applications circumvent this by starting a browser with instructions to access a specific URL. The browser has authority to open a network connection, even though the application does not. Firewall software can attempt to address this by prompting the user in cases where one program starts another which then accesses the network. However, the user frequently does not have sufficient information to determine whether such an access is legitimate—false positives are common, and there is a substantial risk that even sophisticated users will become habituated to clicking "OK" to these prompts.Alfred Spiessens: Patterns of Safe Collaboration, PhD thesis. http://www.evoluware.eu/fsp_thesis.pdf Section 8.1.5 + +Not every program that misuses authority is a confused deputy. Sometimes misuse of authority is simply a result of a program error. The confused deputy problem occurs when the designation of an object is passed from one program to another, and the associated permission changes unintentionally, without any explicit action by either party. It is insidious because neither party did anything explicit to change the authority. + +== Solutions == +In some systems it is possible to ask the operating system to open a file using the permissions of another client. This solution has some drawbacks: +* It requires explicit attention to security by the server. A naive or careless server might not take this extra step. +* It becomes more difficult to identify the correct permission if the server is in turn the client of another service and wants to pass along access to the file. +* It requires the client to trust the server to not abuse the borrowed permissions. Note that intersecting the server and client's permissions does not solve the problem either, because the server may then have to be given very wide permissions (all of the time, rather than those needed for a given request) in order to act for arbitrary clients. + +The simplest way to solve the confused deputy problem is to bundle together the designation of an object and the permission to access that object. This is exactly what a [[object-capability model|capability]] is.{{citation needed|reason=The capability model hardly is a silver bullet.|date=April 2023}} + +Using capability security in the compiler example, the client would pass to the server a capability to the output file, such as a [[file descriptor]], rather than the name of the file. Since it lacks a capability to the billing file, it cannot designate that file for output. In the cross-site request forgery example, a URL supplied "cross"-site would include its own authority independent of that of the client of the web browser. + +== See also == + +* [[Setuid]] executables in Unix +* [[Ambient authority]] + +== References == +{{Reflist}} + +== External links == +* Norman Hardy, ''The Confused Deputy: (or why capabilities might have been invented)'', ACM SIGOPS Operating Systems Review, Volume 22, Issue 4 (October 1988). +** [http://portal.acm.org/citation.cfm?id=871709 ACM published document]. +** [http://cap-lore.com/CapTheory/ConfusedDeputy.html Document text on Norm Hardy's website]. +** [https://web.archive.org/web/20031205034929/http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html Document text on University of Pennsylvania's website]. +** [http://citeseer.ist.psu.edu/hardy94confused.html Citeseer cross reference]. +* [http://cap-lore.com/CapTheory/ Capability Theory Notes from several sources (collated by Norm Hardy)]. +* [https://everything2.com/title/confused+deputy Everything2: Confused Deputy] (some introductory level text). + +{{Object-capability security}} + +[[Category:Computer security]] diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 944a59722..09f8825cf 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -6,8 +6,12 @@ import { makeLogger } from '@ocap/utils'; import { makeCommandStream } from './streams'; import { makeSQLKVStore } from '../kernel/sqlite-kv-store'; +import { Ollama } from 'ollama'; + +const DEFAULT_MODEL = 'deepseek-r1:1.5b'; const vatId = process.env.NODE_VAT_ID as VatId; +const model = process.env.MODEL ?? DEFAULT_MODEL as string; if (vatId) { const logger = makeLogger(`[vat-worker (${vatId})]`); @@ -22,10 +26,23 @@ if (vatId) { async function main(): Promise { const commandStream = makeCommandStream(); await commandStream.synchronize(); + + const host = "http://localhost:11434"; + + // XXX This makes duplicate powers, even for vats that don't need them >:[ + // Some method is necessary for designating the appropriate powers when the + // kernel is starting the vat. Running software doesn't need full isolation, + // only its access within the program; the + const ollama = new Ollama({ host }); + // eslint-disable-next-line no-void void new VatSupervisor({ id: vatId, commandStream, makeKVStore: makeSQLKVStore, + makePowers: async () => { + await ollama.pull({ model }); + return { ollama }; + } }); } diff --git a/packages/nodejs/src/vats/ollama.bundle b/packages/nodejs/src/vats/ollama.bundle deleted file mode 100644 index 2b669cd3a..000000000 --- a/packages/nodejs/src/vats/ollama.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"34e50077d37b65c6e3bfc678b8b285401bedfeaaa802aef4dd443936f4e23da125117086b6a814cf177309e00179ecf842e18fcbae91bfb65f29abdb02575805"} \ No newline at end of file diff --git a/packages/nodejs/src/vats/ollama.js b/packages/nodejs/src/vats/ollama.js deleted file mode 100644 index 67130127e..000000000 --- a/packages/nodejs/src/vats/ollama.js +++ /dev/null @@ -1,39 +0,0 @@ -import { Far } from '@endo/marshal'; - -// The default LLM model to use. -const DEFAULT_MODEL = 'deepseek-r1:1.5b'; - -/** - * Build function for the LLM test vat. - * - * @param {unknown} vatPowers - Special powers granted to this vat. - * @param {() => Promise} vatPowers.chat - A method for awaiting chat results from an LLM. - * @param {unknown} parameters - Initialization parameters from the vat's config object. - * @param {unknown} _baggage - Root of vat's persistent state (not used here). - * @returns {unknown} The root object for the new vat. - */ -export function buildRootObject(vatPowers, parameters, _baggage) { - const model = parameters?.model ?? DEFAULT_MODEL; - const prompt = parameters?.prompt ?? `Say hello.`; - - console.log(`[LLM] buildRootObject "${JSON.stringify({model, prompt, vatPowers})}"`); - - const { chat } = vatPowers; - - return Far('root', { - bootstrap(_) { - chat({ - model, - messages: [{ role: 'user', content: prompt }], - }).then((response) => { - console.log('response:', response); - return undefined; - }).catch((problem) => { - console.error('problem:', problem); - }); - }, - hello(from) { - console.log(`hello, ${from}`); - }, - }); -} diff --git a/packages/nodejs/test/llm/ollama-demo.test.ts b/packages/nodejs/test/llm/ollama-demo.test.ts deleted file mode 100644 index 87ad2fa6c..000000000 --- a/packages/nodejs/test/llm/ollama-demo.test.ts +++ /dev/null @@ -1,66 +0,0 @@ -import '@ocap/shims/endoify'; - -import { Kernel } from '@ocap/kernel'; -import type { VatConfig } from '@ocap/kernel'; -import { - MessageChannel as NodeMessageChannel, - MessagePort as NodePort, -} from 'node:worker_threads'; -import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; - -import { makeKernel } from '../../src/kernel/make-kernel.js'; - -vi.mock('node:process', () => ({ - exit: vi.fn((reason) => { - throw new Error(`process.exit: ${reason}`); - }), -})); - -describe('Ollama Cluster', () => { - let kernelPort: NodePort; - let kernel: Kernel; - - const model = 'deepseek-r1:1.5b'; - const ollamaVatConfig: VatConfig = { - bundleSpec: 'http://localhost:3000/ollama.bundle', - parameters: { - model, - prompt: [ - `You are an instance of LLM model ${model}.`, - 'A user has asked you to give an introduction.', - 'Say hello and show what you can do!', - ].join(' '), - }, - }; - - beforeEach(async () => { - if (kernelPort) { - kernelPort.close(); - } - kernelPort = new NodeMessageChannel().port1; - kernel = await makeKernel(kernelPort); - }); - - afterEach(async () => { - if (kernel) { - await kernel.terminateAllVats(); - await kernel.clearStorage(); - } - }); - - it('hosts an LLM', async () => { - await kernel.launchSubcluster({ - bootstrap: 'ollama', - vats: { - ollama: ollamaVatConfig, - }, - }); - const [vatId] = kernel.getVatIds(); - console.log('vatId', vatId); - await kernel.sendVatCommand(vatId, { - method: 'ping', - params: null, - }); - expect(true).toBe(true); - }, 30_000); -}); diff --git a/packages/nodejs/tsconfig.json b/packages/nodejs/tsconfig.json index e667df516..537a43f4c 100644 --- a/packages/nodejs/tsconfig.json +++ b/packages/nodejs/tsconfig.json @@ -18,13 +18,13 @@ "include": [ "../../vitest.config.packages.ts", "../../vitest.workspace.ts", + "../../types", "./src/**/*.ts", "./src/**/*-trusted-prelude.js", "./test/**/*.ts", + "./test/workers/*.js", "./vitest.config.ts", "./vitest.config.e2e.ts", "./vitest.config.llm.ts", - "../../types", - "./test/workers/*.js" ] } diff --git a/yarn.lock b/yarn.lock index 43018b1b9..6f26aed12 100644 --- a/yarn.lock +++ b/yarn.lock @@ -443,6 +443,13 @@ __metadata: languageName: node linkType: hard +"@cfworker/json-schema@npm:^4.0.2": + version: 4.1.1 + resolution: "@cfworker/json-schema@npm:4.1.1" + checksum: 10/62fd08bb2e6b4f0fe7c2b8f8c19f17f94b6a34feba7f455f228898ab435eda8aae082fcf6b0fe8a235a72e0ec0041922fdcd4c526acc32d45084272f000c1af9 + languageName: node + linkType: hard + "@colors/colors@npm:1.5.0": version: 1.5.0 resolution: "@colors/colors@npm:1.5.0" @@ -496,6 +503,15 @@ __metadata: languageName: node linkType: hard +"@emnapi/runtime@npm:^1.2.0": + version: 1.3.1 + resolution: "@emnapi/runtime@npm:1.3.1" + dependencies: + tslib: "npm:^2.4.0" + checksum: 10/619915ee44682356f77f60455025e667b0b04ad3c95ced36c03782aea9ebc066fa73e86c4a59d221177eba5e5533d40b3a6dbff4e58ee5d81db4270185c21e22 + languageName: node + linkType: hard + "@endo/base64@npm:^1.0.9": version: 1.0.9 resolution: "@endo/base64@npm:1.0.9" @@ -597,7 +613,7 @@ __metadata: languageName: node linkType: hard -"@endo/eventual-send@npm:^1.2.6, @endo/eventual-send@npm:^1.2.7, @endo/eventual-send@npm:^1.2.8": +"@endo/eventual-send@npm:^1.2.6, @endo/eventual-send@npm:^1.2.7, @endo/eventual-send@npm:^1.2.8, @endo/eventual-send@npm:^1.3.0": version: 1.3.0 resolution: "@endo/eventual-send@npm:1.3.0" dependencies: @@ -1264,6 +1280,25 @@ __metadata: languageName: node linkType: hard +"@huggingface/jinja@npm:^0.3.2": + version: 0.3.3 + resolution: "@huggingface/jinja@npm:0.3.3" + checksum: 10/7ca60550a8fcd084a84c34bacb857f12d614ff77463883df824c8759cb29e4a45f87520a25ece9dd4f2ea7f72280883d8040a5cf959c459d586f33bb59450104 + languageName: node + linkType: hard + +"@huggingface/transformers@npm:^3.3.2": + version: 3.3.2 + resolution: "@huggingface/transformers@npm:3.3.2" + dependencies: + "@huggingface/jinja": "npm:^0.3.2" + onnxruntime-node: "npm:1.20.1" + onnxruntime-web: "npm:1.21.0-dev.20250114-228dd16893" + sharp: "npm:^0.33.5" + checksum: 10/ab60a206e4e2410b42c8face58cf2cb3c7655d1b4e2f119b117ba4a8a9eba3ec0194faf5901e793dc0a8f2b6703dadb59509da850ab3171374745a7119b3c24d + languageName: node + linkType: hard + "@humanfs/core@npm:^0.19.1": version: 0.19.1 resolution: "@humanfs/core@npm:0.19.1" @@ -1302,6 +1337,181 @@ __metadata: languageName: node linkType: hard +"@img/sharp-darwin-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-darwin-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-darwin-arm64": + optional: true + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@img/sharp-darwin-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-darwin-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-darwin-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-darwin-x64": + optional: true + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@img/sharp-libvips-darwin-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-darwin-arm64@npm:1.0.4" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@img/sharp-libvips-darwin-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-darwin-x64@npm:1.0.4" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-arm64@npm:1.0.4" + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-arm@npm:1.0.5": + version: 1.0.5 + resolution: "@img/sharp-libvips-linux-arm@npm:1.0.5" + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-s390x@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-s390x@npm:1.0.4" + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-x64@npm:1.0.4" + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4" + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-libvips-linuxmusl-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linuxmusl-x64@npm:1.0.4" + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-linux-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-arm64": + optional: true + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-arm@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-arm@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-arm": "npm:1.0.5" + dependenciesMeta: + "@img/sharp-libvips-linux-arm": + optional: true + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-s390x@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-s390x@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-s390x": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-s390x": + optional: true + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-x64": + optional: true + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linuxmusl-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linuxmusl-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linuxmusl-arm64": + optional: true + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-linuxmusl-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linuxmusl-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linuxmusl-x64": + optional: true + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-wasm32@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-wasm32@npm:0.33.5" + dependencies: + "@emnapi/runtime": "npm:^1.2.0" + conditions: cpu=wasm32 + languageName: node + linkType: hard + +"@img/sharp-win32-ia32@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-win32-ia32@npm:0.33.5" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@img/sharp-win32-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-win32-x64@npm:0.33.5" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + "@inquirer/confirm@npm:^5.0.0": version: 5.1.3 resolution: "@inquirer/confirm@npm:5.1.3" @@ -1419,6 +1629,63 @@ __metadata: languageName: node linkType: hard +"@langchain/core@npm:^0.3.37": + version: 0.3.37 + resolution: "@langchain/core@npm:0.3.37" + dependencies: + "@cfworker/json-schema": "npm:^4.0.2" + ansi-styles: "npm:^5.0.0" + camelcase: "npm:6" + decamelize: "npm:1.2.0" + js-tiktoken: "npm:^1.0.12" + langsmith: "npm:>=0.2.8 <0.4.0" + mustache: "npm:^4.2.0" + p-queue: "npm:^6.6.2" + p-retry: "npm:4" + uuid: "npm:^10.0.0" + zod: "npm:^3.22.4" + zod-to-json-schema: "npm:^3.22.3" + checksum: 10/84c492c806bb420fad79e5e09efe1ece120d7d90f5176c803df39216e965a16f46a3fde3c4af3613c2a31871d94ace31711e65fc2f9ec0368322cdac9c46e194 + languageName: node + linkType: hard + +"@langchain/ollama@npm:^0.1.5": + version: 0.1.5 + resolution: "@langchain/ollama@npm:0.1.5" + dependencies: + ollama: "npm:^0.5.9" + uuid: "npm:^10.0.0" + peerDependencies: + "@langchain/core": ">=0.2.21 <0.4.0" + checksum: 10/541e9a8bad78f07e81c6c3b60c1f8eb40cacca27debd50a231a69eaa98539b60fb57744d3227f2bb9525118b30d049818a51211b2b194d1e448e003e803b4013 + languageName: node + linkType: hard + +"@langchain/openai@npm:>=0.1.0 <0.5.0, @langchain/openai@npm:^0.4.2": + version: 0.4.2 + resolution: "@langchain/openai@npm:0.4.2" + dependencies: + js-tiktoken: "npm:^1.0.12" + openai: "npm:^4.77.0" + zod: "npm:^3.22.4" + zod-to-json-schema: "npm:^3.22.3" + peerDependencies: + "@langchain/core": ">=0.3.29 <0.4.0" + checksum: 10/8be655ce71e33dfd62b8b25c9dedce1e30a29593b5e213e161763eee3f51366f988987049fff29a1a6123405586767af93d34e7723ed82f264d3cd2689dc7995 + languageName: node + linkType: hard + +"@langchain/textsplitters@npm:>=0.0.0 <0.2.0": + version: 0.1.0 + resolution: "@langchain/textsplitters@npm:0.1.0" + dependencies: + js-tiktoken: "npm:^1.0.12" + peerDependencies: + "@langchain/core": ">=0.2.21 <0.4.0" + checksum: 10/87121ec5ad003834ca5b5d1cb6c949c0744df3411011546dedf7bc8e04e2572a9663aadf2d70c25acdf7364845e00c30c039b610ff19b3f15429adcd059838b3 + languageName: node + linkType: hard + "@lavamoat/aa@npm:^4.3.1": version: 4.3.1 resolution: "@lavamoat/aa@npm:4.3.1" @@ -2214,7 +2481,6 @@ __metadata: eslint-plugin-n: "npm:^17.11.1" eslint-plugin-prettier: "npm:^5.2.1" eslint-plugin-promise: "npm:^7.1.0" - ollama: "npm:^0.5.12" prettier: "npm:^3.3.3" rimraf: "npm:^6.0.1" ses: "npm:^1.9.0" @@ -2294,8 +2560,13 @@ __metadata: resolution: "@ocap/nodejs@workspace:packages/nodejs" dependencies: "@arethetypeswrong/cli": "npm:^0.17.3" + "@endo/eventual-send": "npm:^1.3.0" "@endo/marshal": "npm:^1.6.2" "@endo/promise-kit": "npm:^1.1.6" + "@huggingface/transformers": "npm:^3.3.2" + "@langchain/core": "npm:^0.3.37" + "@langchain/ollama": "npm:^0.1.5" + "@langchain/openai": "npm:^0.4.2" "@metamask/auto-changelog": "npm:^4.0.0" "@metamask/eslint-config": "npm:^14.0.0" "@metamask/eslint-config-nodejs": "npm:^14.0.0" @@ -2323,11 +2594,13 @@ __metadata: eslint-plugin-n: "npm:^17.11.1" eslint-plugin-prettier: "npm:^5.2.1" eslint-plugin-promise: "npm:^7.1.0" + langchain: "npm:^0.3.15" node-gyp: "npm:^11.0.0" ollama: "npm:^0.5.12" prettier: "npm:^3.3.3" rimraf: "npm:^6.0.1" ses: "npm:^1.9.0" + tsx: "npm:^4.19.2" typedoc: "npm:^0.27.6" typescript: "npm:~5.5.4" typescript-eslint: "npm:^8.8.1" @@ -2691,6 +2964,79 @@ __metadata: languageName: node linkType: hard +"@protobufjs/aspromise@npm:^1.1.1, @protobufjs/aspromise@npm:^1.1.2": + version: 1.1.2 + resolution: "@protobufjs/aspromise@npm:1.1.2" + checksum: 10/8a938d84fe4889411296db66b29287bd61ea3c14c2d23e7a8325f46a2b8ce899857c5f038d65d7641805e6c1d06b495525c7faf00c44f85a7ee6476649034969 + languageName: node + linkType: hard + +"@protobufjs/base64@npm:^1.1.2": + version: 1.1.2 + resolution: "@protobufjs/base64@npm:1.1.2" + checksum: 10/c71b100daeb3c9bdccab5cbc29495b906ba0ae22ceedc200e1ba49717d9c4ab15a6256839cebb6f9c6acae4ed7c25c67e0a95e734f612b258261d1a3098fe342 + languageName: node + linkType: hard + +"@protobufjs/codegen@npm:^2.0.4": + version: 2.0.4 + resolution: "@protobufjs/codegen@npm:2.0.4" + checksum: 10/c6ee5fa172a8464f5253174d3c2353ea520c2573ad7b6476983d9b1346f4d8f2b44aa29feb17a949b83c1816bc35286a5ea265ed9d8fdd2865acfa09668c0447 + languageName: node + linkType: hard + +"@protobufjs/eventemitter@npm:^1.1.0": + version: 1.1.0 + resolution: "@protobufjs/eventemitter@npm:1.1.0" + checksum: 10/03af3e99f17ad421283d054c88a06a30a615922a817741b43ca1b13e7c6b37820a37f6eba9980fb5150c54dba6e26cb6f7b64a6f7d8afa83596fafb3afa218c3 + languageName: node + linkType: hard + +"@protobufjs/fetch@npm:^1.1.0": + version: 1.1.0 + resolution: "@protobufjs/fetch@npm:1.1.0" + dependencies: + "@protobufjs/aspromise": "npm:^1.1.1" + "@protobufjs/inquire": "npm:^1.1.0" + checksum: 10/67ae40572ad536e4ef94269199f252c024b66e3059850906bdaee161ca1d75c73d04d35cd56f147a8a5a079f5808e342b99e61942c1dae15604ff0600b09a958 + languageName: node + linkType: hard + +"@protobufjs/float@npm:^1.0.2": + version: 1.0.2 + resolution: "@protobufjs/float@npm:1.0.2" + checksum: 10/634c2c989da0ef2f4f19373d64187e2a79f598c5fb7991afb689d29a2ea17c14b796b29725945fa34b9493c17fb799e08ac0a7ccaae460ee1757d3083ed35187 + languageName: node + linkType: hard + +"@protobufjs/inquire@npm:^1.1.0": + version: 1.1.0 + resolution: "@protobufjs/inquire@npm:1.1.0" + checksum: 10/c09efa34a5465cb120775e1a482136f2340a58b4abce7e93d72b8b5a9324a0e879275016ef9fcd73d72a4731639c54f2bb755bb82f916e4a78892d1d840bb3d2 + languageName: node + linkType: hard + +"@protobufjs/path@npm:^1.1.2": + version: 1.1.2 + resolution: "@protobufjs/path@npm:1.1.2" + checksum: 10/bb709567935fd385a86ad1f575aea98131bbd719c743fb9b6edd6b47ede429ff71a801cecbd64fc72deebf4e08b8f1bd8062793178cdaed3713b8d15771f9b83 + languageName: node + linkType: hard + +"@protobufjs/pool@npm:^1.1.0": + version: 1.1.0 + resolution: "@protobufjs/pool@npm:1.1.0" + checksum: 10/b9c7047647f6af28e92aac54f6f7c1f7ff31b201b4bfcc7a415b2861528854fce3ec666d7e7e10fd744da905f7d4aef2205bbcc8944ca0ca7a82e18134d00c46 + languageName: node + linkType: hard + +"@protobufjs/utf8@npm:^1.1.0": + version: 1.1.0 + resolution: "@protobufjs/utf8@npm:1.1.0" + checksum: 10/131e289c57534c1d73a0e55782d6751dd821db1583cb2f7f7e017c9d6747addaebe79f28120b2e0185395d990aad347fb14ffa73ef4096fa38508d61a0e64602 + languageName: node + linkType: hard + "@rollup/plugin-commonjs@npm:^19.0.0": version: 19.0.2 resolution: "@rollup/plugin-commonjs@npm:19.0.2" @@ -3298,6 +3644,16 @@ __metadata: languageName: node linkType: hard +"@types/node-fetch@npm:^2.6.4": + version: 2.6.12 + resolution: "@types/node-fetch@npm:2.6.12" + dependencies: + "@types/node": "npm:*" + form-data: "npm:^4.0.0" + checksum: 10/8107c479da83a3114fcbfa882eba95ee5175cccb5e4dd53f737a96f2559ae6262f662176b8457c1656de09ec393cc7b20a266c077e4bfb21e929976e1cf4d0f9 + languageName: node + linkType: hard + "@types/node@npm:*, @types/node@npm:^22.10.1": version: 22.10.7 resolution: "@types/node@npm:22.10.7" @@ -3307,6 +3663,24 @@ __metadata: languageName: node linkType: hard +"@types/node@npm:>=13.7.0": + version: 22.13.0 + resolution: "@types/node@npm:22.13.0" + dependencies: + undici-types: "npm:~6.20.0" + checksum: 10/a7563e57df48cb7e28f936dbabe228316dcdb4c7c3a88a6c1659fae898ffde2647a7193a9e29e0cbcb7dacc05a91fb3bc30c1a1d6fc9294694a734ff71a5f12e + languageName: node + linkType: hard + +"@types/node@npm:^18.11.18": + version: 18.19.74 + resolution: "@types/node@npm:18.19.74" + dependencies: + undici-types: "npm:~5.26.4" + checksum: 10/2306bd0b41cdd528b890b210b96f287a5b5035c128f62636057d6616bd612b3f53d32d77f7e76ef41a9f130ea691e6980e6d5942dd625df05d3a641764fddb78 + languageName: node + linkType: hard + "@types/parse-json@npm:^4.0.0": version: 4.0.2 resolution: "@types/parse-json@npm:4.0.2" @@ -3367,6 +3741,13 @@ __metadata: languageName: node linkType: hard +"@types/retry@npm:0.12.0": + version: 0.12.0 + resolution: "@types/retry@npm:0.12.0" + checksum: 10/bbd0b88f4b3eba7b7acfc55ed09c65ef6f2e1bcb4ec9b4dca82c66566934351534317d294a770a7cc6c0468d5573c5350abab6e37c65f8ef254443e1b028e44d + languageName: node + linkType: hard + "@types/serve-handler@npm:^6": version: 6.1.4 resolution: "@types/serve-handler@npm:6.1.4" @@ -3404,6 +3785,13 @@ __metadata: languageName: node linkType: hard +"@types/uuid@npm:^10.0.0": + version: 10.0.0 + resolution: "@types/uuid@npm:10.0.0" + checksum: 10/e3958f8b0fe551c86c14431f5940c3470127293280830684154b91dc7eb3514aeb79fe3216968833cf79d4d1c67f580f054b5be2cd562bebf4f728913e73e944 + languageName: node + linkType: hard + "@types/webextension-polyfill@npm:^0": version: 0.12.1 resolution: "@types/webextension-polyfill@npm:0.12.1" @@ -3895,6 +4283,15 @@ __metadata: languageName: node linkType: hard +"agentkeepalive@npm:^4.2.1": + version: 4.6.0 + resolution: "agentkeepalive@npm:4.6.0" + dependencies: + humanize-ms: "npm:^1.2.1" + checksum: 10/80c546bd88dd183376d6a29e5598f117f380b1d567feb1de184241d6ece721e2bdd38f179a1674276de01780ccae229a38c60a77317e2f5ad2f1818856445bd7 + languageName: node + linkType: hard + "aggregate-error@npm:^3.0.0": version: 3.1.0 resolution: "aggregate-error@npm:3.1.0" @@ -4266,7 +4663,7 @@ __metadata: languageName: node linkType: hard -"base64-js@npm:^1.3.1": +"base64-js@npm:^1.3.1, base64-js@npm:^1.5.1": version: 1.5.1 resolution: "base64-js@npm:1.5.1" checksum: 10/669632eb3745404c2f822a18fc3a0122d2f9a7a13f7fb8b5823ee19d1d2ff9ee5b52c53367176ea4ad093c332fd5ab4bd0ebae5a8e27917a4105a4cfc86b1005 @@ -4527,7 +4924,7 @@ __metadata: languageName: node linkType: hard -"camelcase@npm:^6.3.0": +"camelcase@npm:6, camelcase@npm:^6.3.0": version: 6.3.0 resolution: "camelcase@npm:6.3.0" checksum: 10/8c96818a9076434998511251dcb2761a94817ea17dbdc37f47ac080bd088fc62c7369429a19e2178b993497132c8cbcf5cc1f44ba963e76782ba469c0474938d @@ -4823,13 +5220,33 @@ __metadata: languageName: node linkType: hard -"color-name@npm:~1.1.4": +"color-name@npm:^1.0.0, color-name@npm:~1.1.4": version: 1.1.4 resolution: "color-name@npm:1.1.4" checksum: 10/b0445859521eb4021cd0fb0cc1a75cecf67fceecae89b63f62b201cca8d345baf8b952c966862a9d9a2632987d4f6581f0ec8d957dfacece86f0a7919316f610 languageName: node linkType: hard +"color-string@npm:^1.9.0": + version: 1.9.1 + resolution: "color-string@npm:1.9.1" + dependencies: + color-name: "npm:^1.0.0" + simple-swizzle: "npm:^0.2.2" + checksum: 10/72aa0b81ee71b3f4fb1ac9cd839cdbd7a011a7d318ef58e6cb13b3708dca75c7e45029697260488709f1b1c7ac4e35489a87e528156c1e365917d1c4ccb9b9cd + languageName: node + linkType: hard + +"color@npm:^4.2.3": + version: 4.2.3 + resolution: "color@npm:4.2.3" + dependencies: + color-convert: "npm:^2.0.1" + color-string: "npm:^1.9.0" + checksum: 10/b23f5e500a79ea22428db43d1a70642d983405c0dd1f95ef59dbdb9ba66afbb4773b334fa0b75bb10b0552fd7534c6b28d4db0a8b528f91975976e70973c0152 + languageName: node + linkType: hard + "colorette@npm:^2.0.20": version: 2.0.20 resolution: "colorette@npm:2.0.20" @@ -4918,6 +5335,15 @@ __metadata: languageName: node linkType: hard +"console-table-printer@npm:^2.12.1": + version: 2.12.1 + resolution: "console-table-printer@npm:2.12.1" + dependencies: + simple-wcswidth: "npm:^1.0.1" + checksum: 10/37ac91d3601aa6747d3a895487ec9271488c5dae9154745513b6bfbb74f46c414aa4d8e86197b915be9565d1dd2b38005466fa94814ff62b1a08c4e37d57b601 + languageName: node + linkType: hard + "content-disposition@npm:0.5.2": version: 0.5.2 resolution: "content-disposition@npm:0.5.2" @@ -5132,6 +5558,13 @@ __metadata: languageName: node linkType: hard +"decamelize@npm:1.2.0": + version: 1.2.0 + resolution: "decamelize@npm:1.2.0" + checksum: 10/ad8c51a7e7e0720c70ec2eeb1163b66da03e7616d7b98c9ef43cce2416395e84c1e9548dd94f5f6ffecfee9f8b94251fc57121a8b021f2ff2469b2bae247b8aa + languageName: node + linkType: hard + "decimal.js@npm:^10.4.3": version: 10.4.3 resolution: "decimal.js@npm:10.4.3" @@ -5289,7 +5722,7 @@ __metadata: languageName: node linkType: hard -"detect-libc@npm:^2.0.0": +"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.3": version: 2.0.3 resolution: "detect-libc@npm:2.0.3" checksum: 10/b4ea018d623e077bd395f168a9e81db77370dde36a5b01d067f2ad7989924a81d31cb547ff764acb2aa25d50bb7fdde0b0a93bec02212b0cb430621623246d39 @@ -6254,6 +6687,13 @@ __metadata: languageName: node linkType: hard +"eventemitter3@npm:^4.0.4": + version: 4.0.7 + resolution: "eventemitter3@npm:4.0.7" + checksum: 10/8030029382404942c01d0037079f1b1bc8fed524b5849c237b80549b01e2fc49709e1d0c557fa65ca4498fc9e24cff1475ef7b855121fcc15f9d61f93e282346 + languageName: node + linkType: hard + "eventemitter3@npm:^5.0.1": version: 5.0.1 resolution: "eventemitter3@npm:5.0.1" @@ -6532,6 +6972,13 @@ __metadata: languageName: node linkType: hard +"flatbuffers@npm:^1.12.0": + version: 1.12.0 + resolution: "flatbuffers@npm:1.12.0" + checksum: 10/cab05829660c89e01e4074cb07e3d1d79c1955e278221866f9e7ef28d5de89852f83a84084e4e83bac6bfac65108a261f9da36f5034a3145d8dc013c9959ed12 + languageName: node + linkType: hard + "flatted@npm:^3.2.9": version: 3.3.2 resolution: "flatted@npm:3.3.2" @@ -6558,6 +7005,13 @@ __metadata: languageName: node linkType: hard +"form-data-encoder@npm:1.7.2": + version: 1.7.2 + resolution: "form-data-encoder@npm:1.7.2" + checksum: 10/227bf2cea083284411fd67472ccc22f5cb354ca92c00690e11ff5ed942d993c13ac99dea365046306200f8bd71e1a7858d2d99e236de694b806b1f374a4ee341 + languageName: node + linkType: hard + "form-data@npm:^4.0.0": version: 4.0.1 resolution: "form-data@npm:4.0.1" @@ -6569,6 +7023,16 @@ __metadata: languageName: node linkType: hard +"formdata-node@npm:^4.3.2": + version: 4.4.1 + resolution: "formdata-node@npm:4.4.1" + dependencies: + node-domexception: "npm:1.0.0" + web-streams-polyfill: "npm:4.0.0-beta.3" + checksum: 10/29622f75533107c1bbcbe31fda683e6a55859af7f48ec354a9800591ce7947ed84cd3ef2b2fcb812047a884f17a1bac75ce098ffc17e23402cd373e49c1cd335 + languageName: node + linkType: hard + "fs-constants@npm:^1.0.0": version: 1.0.0 resolution: "fs-constants@npm:1.0.0" @@ -6960,6 +7424,13 @@ __metadata: languageName: node linkType: hard +"guid-typescript@npm:^1.0.9": + version: 1.0.9 + resolution: "guid-typescript@npm:1.0.9" + checksum: 10/829dd87866800a5138aafa0873994028bbc446eb20ff4cae6452d471a2a3d26f7025bed3eb980692c0f022fd22f95ea7396122b46b45a4b5084958505a4fc50c + languageName: node + linkType: hard + "has-bigints@npm:^1.0.2": version: 1.1.0 resolution: "has-bigints@npm:1.1.0" @@ -7125,6 +7596,15 @@ __metadata: languageName: node linkType: hard +"humanize-ms@npm:^1.2.1": + version: 1.2.1 + resolution: "humanize-ms@npm:1.2.1" + dependencies: + ms: "npm:^2.0.0" + checksum: 10/9c7a74a2827f9294c009266c82031030eae811ca87b0da3dceb8d6071b9bde22c9f3daef0469c3c533cc67a97d8a167cd9fc0389350e5f415f61a79b171ded16 + languageName: node + linkType: hard + "iconv-lite@npm:0.6.3, iconv-lite@npm:^0.6.2, iconv-lite@npm:^0.6.3": version: 0.6.3 resolution: "iconv-lite@npm:0.6.3" @@ -7304,6 +7784,13 @@ __metadata: languageName: node linkType: hard +"is-arrayish@npm:^0.3.1": + version: 0.3.2 + resolution: "is-arrayish@npm:0.3.2" + checksum: 10/81a78d518ebd8b834523e25d102684ee0f7e98637136d3bdc93fd09636350fa06f1d8ca997ea28143d4d13cb1b69c0824f082db0ac13e1ab3311c10ffea60ade + languageName: node + linkType: hard + "is-async-function@npm:^2.0.0": version: 2.1.0 resolution: "is-async-function@npm:2.1.0" @@ -7806,6 +8293,15 @@ __metadata: languageName: node linkType: hard +"js-tiktoken@npm:^1.0.12": + version: 1.0.16 + resolution: "js-tiktoken@npm:1.0.16" + dependencies: + base64-js: "npm:^1.5.1" + checksum: 10/f56717315070baa2629d031117212289621782c3d428edf4f7a78ea41ad60cf1d45585dc8531271f4952d58166f5cc704e024f39d79f0af75f6fc63d6ad011d5 + languageName: node + linkType: hard + "js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0": version: 4.0.0 resolution: "js-tokens@npm:4.0.0" @@ -7966,6 +8462,13 @@ __metadata: languageName: node linkType: hard +"jsonpointer@npm:^5.0.1": + version: 5.0.1 + resolution: "jsonpointer@npm:5.0.1" + checksum: 10/0b40f712900ad0c846681ea2db23b6684b9d5eedf55807b4708c656f5894b63507d0e28ae10aa1bddbea551241035afe62b6df0800fc94c2e2806a7f3adecd7c + languageName: node + linkType: hard + "jsx-ast-utils@npm:^2.4.1 || ^3.0.0": version: 3.3.5 resolution: "jsx-ast-utils@npm:3.3.5" @@ -7987,6 +8490,97 @@ __metadata: languageName: node linkType: hard +"langchain@npm:^0.3.15": + version: 0.3.15 + resolution: "langchain@npm:0.3.15" + dependencies: + "@langchain/openai": "npm:>=0.1.0 <0.5.0" + "@langchain/textsplitters": "npm:>=0.0.0 <0.2.0" + js-tiktoken: "npm:^1.0.12" + js-yaml: "npm:^4.1.0" + jsonpointer: "npm:^5.0.1" + langsmith: "npm:>=0.2.8 <0.4.0" + openapi-types: "npm:^12.1.3" + p-retry: "npm:4" + uuid: "npm:^10.0.0" + yaml: "npm:^2.2.1" + zod: "npm:^3.22.4" + zod-to-json-schema: "npm:^3.22.3" + peerDependencies: + "@langchain/anthropic": "*" + "@langchain/aws": "*" + "@langchain/cerebras": "*" + "@langchain/cohere": "*" + "@langchain/core": ">=0.2.21 <0.4.0" + "@langchain/deepseek": "*" + "@langchain/google-genai": "*" + "@langchain/google-vertexai": "*" + "@langchain/google-vertexai-web": "*" + "@langchain/groq": "*" + "@langchain/mistralai": "*" + "@langchain/ollama": "*" + axios: "*" + cheerio: "*" + handlebars: ^4.7.8 + peggy: ^3.0.2 + typeorm: "*" + peerDependenciesMeta: + "@langchain/anthropic": + optional: true + "@langchain/aws": + optional: true + "@langchain/cerebras": + optional: true + "@langchain/cohere": + optional: true + "@langchain/deepseek": + optional: true + "@langchain/google-genai": + optional: true + "@langchain/google-vertexai": + optional: true + "@langchain/google-vertexai-web": + optional: true + "@langchain/groq": + optional: true + "@langchain/mistralai": + optional: true + "@langchain/ollama": + optional: true + axios: + optional: true + cheerio: + optional: true + handlebars: + optional: true + peggy: + optional: true + typeorm: + optional: true + checksum: 10/a4e4d8b024a997376319104ca3a892783a16b6a787f97c250008029c883b8fce8bc1d50e029bcb86e626db1828e7e2cfc22851a2c79a800884639563e9501e3b + languageName: node + linkType: hard + +"langsmith@npm:>=0.2.8 <0.4.0": + version: 0.3.4 + resolution: "langsmith@npm:0.3.4" + dependencies: + "@types/uuid": "npm:^10.0.0" + chalk: "npm:^4.1.2" + console-table-printer: "npm:^2.12.1" + p-queue: "npm:^6.6.2" + p-retry: "npm:4" + semver: "npm:^7.6.3" + uuid: "npm:^10.0.0" + peerDependencies: + openai: "*" + peerDependenciesMeta: + openai: + optional: true + checksum: 10/1c74d42a113b043560282176b45aef02a02585c864a4fb732acc655c5566e575daa70f0f93fe815beb137ad8bda6b73cd7bfb4917ead7d9984deedf29d207532 + languageName: node + linkType: hard + "less@npm:^4.2.0": version: 4.2.1 resolution: "less@npm:4.2.1" @@ -8146,6 +8740,13 @@ __metadata: languageName: node linkType: hard +"long@npm:^5.0.0, long@npm:^5.2.3": + version: 5.2.4 + resolution: "long@npm:5.2.4" + checksum: 10/c27c060a683d4d76dc48da12ded0ae49c610aaf10d028ec938829d7bebe916979dcc8b67ed71f8bf6d845a90151b66a9b741a3ee51ec874908e496c2a576697a + languageName: node + linkType: hard + "loose-envify@npm:^1.1.0, loose-envify@npm:^1.4.0": version: 1.4.0 resolution: "loose-envify@npm:1.4.0" @@ -8680,7 +9281,7 @@ __metadata: languageName: node linkType: hard -"ms@npm:^2.1.1, ms@npm:^2.1.3": +"ms@npm:^2.0.0, ms@npm:^2.1.1, ms@npm:^2.1.3": version: 2.1.3 resolution: "ms@npm:2.1.3" checksum: 10/aa92de608021b242401676e35cfa5aa42dd70cbdc082b916da7fb925c542173e36bce97ea3e804923fe92c0ad991434e4a38327e15a1b5b5f945d66df615ae6d @@ -8733,6 +9334,15 @@ __metadata: languageName: node linkType: hard +"mustache@npm:^4.2.0": + version: 4.2.0 + resolution: "mustache@npm:4.2.0" + bin: + mustache: bin/mustache + checksum: 10/6e668bd5803255ab0779c3983b9412b5c4f4f90e822230e0e8f414f5449ed7a137eed29430e835aa689886f663385cfe05f808eb34b16e1f3a95525889b05cd3 + languageName: node + linkType: hard + "mute-stream@npm:^2.0.0": version: 2.0.0 resolution: "mute-stream@npm:2.0.0" @@ -8818,6 +9428,13 @@ __metadata: languageName: node linkType: hard +"node-domexception@npm:1.0.0": + version: 1.0.0 + resolution: "node-domexception@npm:1.0.0" + checksum: 10/e332522f242348c511640c25a6fc7da4f30e09e580c70c6b13cb0be83c78c3e71c8d4665af2527e869fc96848924a4316ae7ec9014c091e2156f41739d4fa233 + languageName: node + linkType: hard + "node-emoji@npm:^2.1.3": version: 2.2.0 resolution: "node-emoji@npm:2.2.0" @@ -9103,7 +9720,7 @@ __metadata: languageName: node linkType: hard -"ollama@npm:^0.5.12": +"ollama@npm:^0.5.12, ollama@npm:^0.5.9": version: 0.5.12 resolution: "ollama@npm:0.5.12" dependencies: @@ -9148,6 +9765,77 @@ __metadata: languageName: node linkType: hard +"onnxruntime-common@npm:1.20.1": + version: 1.20.1 + resolution: "onnxruntime-common@npm:1.20.1" + checksum: 10/242ee8ad2fde620a4d1ea64501fa23b4fbd95c3c8a816969e12321e37c4b6c642c1043308b371c8ebed19784a0b9f3526182e20a2d87b9ca3753b79918b143c7 + languageName: node + linkType: hard + +"onnxruntime-common@npm:1.21.0-dev.20241212-1f88284f96": + version: 1.21.0-dev.20241212-1f88284f96 + resolution: "onnxruntime-common@npm:1.21.0-dev.20241212-1f88284f96" + checksum: 10/c58ce123223841758fc89cca63fe1b64970352f26c64fc5249d106fa86db379f1ebae1ea635d94f0e4ef78111d7f317a084c4e7eba556dad1d070194e0a5a166 + languageName: node + linkType: hard + +"onnxruntime-node@npm:1.20.1": + version: 1.20.1 + resolution: "onnxruntime-node@npm:1.20.1" + dependencies: + onnxruntime-common: "npm:1.20.1" + tar: "npm:^7.0.1" + checksum: 10/4104d62beae79a884c5ff940887eea711f1634af2b2df64fe2d00c893be1a41ae1992176147e3f5b2bb4be5efb09975e7cbe820d52c2d32c81e386536a27d3e6 + conditions: (os=win32 | os=darwin | os=linux) + languageName: node + linkType: hard + +"onnxruntime-web@npm:1.21.0-dev.20250114-228dd16893": + version: 1.21.0-dev.20250114-228dd16893 + resolution: "onnxruntime-web@npm:1.21.0-dev.20250114-228dd16893" + dependencies: + flatbuffers: "npm:^1.12.0" + guid-typescript: "npm:^1.0.9" + long: "npm:^5.2.3" + onnxruntime-common: "npm:1.21.0-dev.20241212-1f88284f96" + platform: "npm:^1.3.6" + protobufjs: "npm:^7.2.4" + checksum: 10/bb0cf8d868ff24b186b928791a46dd78840cc59f6540aa4fd12c2db78a889f7164ff3f075995aed9fe2f93f558359a874b62403aa38c0b6527c2fceb434b9462 + languageName: node + linkType: hard + +"openai@npm:^4.77.0": + version: 4.82.0 + resolution: "openai@npm:4.82.0" + dependencies: + "@types/node": "npm:^18.11.18" + "@types/node-fetch": "npm:^2.6.4" + abort-controller: "npm:^3.0.0" + agentkeepalive: "npm:^4.2.1" + form-data-encoder: "npm:1.7.2" + formdata-node: "npm:^4.3.2" + node-fetch: "npm:^2.6.7" + peerDependencies: + ws: ^8.18.0 + zod: ^3.23.8 + peerDependenciesMeta: + ws: + optional: true + zod: + optional: true + bin: + openai: bin/cli + checksum: 10/1d2d9c11ebfd3d1dac3c9feead20517d4d1f22b3f16e9dc71d0bf54852e5323ddf5f9de81f08e90ccf0520192aa54a9e6779b947293cd7dc8453872784576167 + languageName: node + linkType: hard + +"openapi-types@npm:^12.1.3": + version: 12.1.3 + resolution: "openapi-types@npm:12.1.3" + checksum: 10/9d1d7ed848622b63d0a4c3f881689161b99427133054e46b8e3241e137f1c78bb0031c5d80b420ee79ac2e91d2e727ffd6fc13c553d1b0488ddc8ad389dcbef8 + languageName: node + linkType: hard + "optionator@npm:^0.9.3": version: 0.9.4 resolution: "optionator@npm:0.9.4" @@ -9180,6 +9868,13 @@ __metadata: languageName: node linkType: hard +"p-finally@npm:^1.0.0": + version: 1.0.0 + resolution: "p-finally@npm:1.0.0" + checksum: 10/93a654c53dc805dd5b5891bab16eb0ea46db8f66c4bfd99336ae929323b1af2b70a8b0654f8f1eae924b2b73d037031366d645f1fd18b3d30cbd15950cc4b1d4 + languageName: node + linkType: hard + "p-limit@npm:^3.0.2": version: 3.1.0 resolution: "p-limit@npm:3.1.0" @@ -9214,6 +9909,35 @@ __metadata: languageName: node linkType: hard +"p-queue@npm:^6.6.2": + version: 6.6.2 + resolution: "p-queue@npm:6.6.2" + dependencies: + eventemitter3: "npm:^4.0.4" + p-timeout: "npm:^3.2.0" + checksum: 10/60fe227ffce59fbc5b1b081305b61a2f283ff145005853702b7d4d3f99a0176bd21bb126c99a962e51fe1e01cb8aa10f0488b7bbe73b5dc2e84b5cc650b8ffd2 + languageName: node + linkType: hard + +"p-retry@npm:4": + version: 4.6.2 + resolution: "p-retry@npm:4.6.2" + dependencies: + "@types/retry": "npm:0.12.0" + retry: "npm:^0.13.1" + checksum: 10/45c270bfddaffb4a895cea16cb760dcc72bdecb6cb45fef1971fa6ea2e91ddeafddefe01e444ac73e33b1b3d5d29fb0dd18a7effb294262437221ddc03ce0f2e + languageName: node + linkType: hard + +"p-timeout@npm:^3.2.0": + version: 3.2.0 + resolution: "p-timeout@npm:3.2.0" + dependencies: + p-finally: "npm:^1.0.0" + checksum: 10/3dd0eaa048780a6f23e5855df3dd45c7beacff1f820476c1d0d1bcd6648e3298752ba2c877aa1c92f6453c7dd23faaf13d9f5149fc14c0598a142e2c5e8d649c + languageName: node + linkType: hard + "package-config@npm:^5.0.0": version: 5.0.0 resolution: "package-config@npm:5.0.0" @@ -9475,6 +10199,13 @@ __metadata: languageName: node linkType: hard +"platform@npm:^1.3.6": + version: 1.3.6 + resolution: "platform@npm:1.3.6" + checksum: 10/1f2d8333e23ea6a7620c828d2fc1ccbbd33e01928fb142323420506114d7325ebdeb1b38544efbf64e90ab73af0847f874d0f475b9327bcf53510fa827a4ef95 + languageName: node + linkType: hard + "playwright-core@npm:1.50.0": version: 1.50.0 resolution: "playwright-core@npm:1.50.0" @@ -9741,6 +10472,26 @@ __metadata: languageName: node linkType: hard +"protobufjs@npm:^7.2.4": + version: 7.4.0 + resolution: "protobufjs@npm:7.4.0" + dependencies: + "@protobufjs/aspromise": "npm:^1.1.2" + "@protobufjs/base64": "npm:^1.1.2" + "@protobufjs/codegen": "npm:^2.0.4" + "@protobufjs/eventemitter": "npm:^1.1.0" + "@protobufjs/fetch": "npm:^1.1.0" + "@protobufjs/float": "npm:^1.0.2" + "@protobufjs/inquire": "npm:^1.1.0" + "@protobufjs/path": "npm:^1.1.2" + "@protobufjs/pool": "npm:^1.1.0" + "@protobufjs/utf8": "npm:^1.1.0" + "@types/node": "npm:>=13.7.0" + long: "npm:^5.0.0" + checksum: 10/408423506610f70858d7593632f4a6aa4f05796c90fd632be9b9252457c795acc71aa6d3b54bb7f48a890141728fee4ca3906723ccea6c202ad71f21b3879b8b + languageName: node + linkType: hard + "prr@npm:~1.0.1": version: 1.0.1 resolution: "prr@npm:1.0.1" @@ -10129,6 +10880,13 @@ __metadata: languageName: node linkType: hard +"retry@npm:^0.13.1": + version: 0.13.1 + resolution: "retry@npm:0.13.1" + checksum: 10/6125ec2e06d6e47e9201539c887defba4e47f63471db304c59e4b82fc63c8e89ca06a77e9d34939a9a42a76f00774b2f46c0d4a4cbb3e287268bd018ed69426d + languageName: node + linkType: hard + "reusify@npm:^1.0.4": version: 1.0.4 resolution: "reusify@npm:1.0.4" @@ -10498,6 +11256,75 @@ __metadata: languageName: node linkType: hard +"sharp@npm:^0.33.5": + version: 0.33.5 + resolution: "sharp@npm:0.33.5" + dependencies: + "@img/sharp-darwin-arm64": "npm:0.33.5" + "@img/sharp-darwin-x64": "npm:0.33.5" + "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" + "@img/sharp-libvips-darwin-x64": "npm:1.0.4" + "@img/sharp-libvips-linux-arm": "npm:1.0.5" + "@img/sharp-libvips-linux-arm64": "npm:1.0.4" + "@img/sharp-libvips-linux-s390x": "npm:1.0.4" + "@img/sharp-libvips-linux-x64": "npm:1.0.4" + "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" + "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" + "@img/sharp-linux-arm": "npm:0.33.5" + "@img/sharp-linux-arm64": "npm:0.33.5" + "@img/sharp-linux-s390x": "npm:0.33.5" + "@img/sharp-linux-x64": "npm:0.33.5" + "@img/sharp-linuxmusl-arm64": "npm:0.33.5" + "@img/sharp-linuxmusl-x64": "npm:0.33.5" + "@img/sharp-wasm32": "npm:0.33.5" + "@img/sharp-win32-ia32": "npm:0.33.5" + "@img/sharp-win32-x64": "npm:0.33.5" + color: "npm:^4.2.3" + detect-libc: "npm:^2.0.3" + semver: "npm:^7.6.3" + dependenciesMeta: + "@img/sharp-darwin-arm64": + optional: true + "@img/sharp-darwin-x64": + optional: true + "@img/sharp-libvips-darwin-arm64": + optional: true + "@img/sharp-libvips-darwin-x64": + optional: true + "@img/sharp-libvips-linux-arm": + optional: true + "@img/sharp-libvips-linux-arm64": + optional: true + "@img/sharp-libvips-linux-s390x": + optional: true + "@img/sharp-libvips-linux-x64": + optional: true + "@img/sharp-libvips-linuxmusl-arm64": + optional: true + "@img/sharp-libvips-linuxmusl-x64": + optional: true + "@img/sharp-linux-arm": + optional: true + "@img/sharp-linux-arm64": + optional: true + "@img/sharp-linux-s390x": + optional: true + "@img/sharp-linux-x64": + optional: true + "@img/sharp-linuxmusl-arm64": + optional: true + "@img/sharp-linuxmusl-x64": + optional: true + "@img/sharp-wasm32": + optional: true + "@img/sharp-win32-ia32": + optional: true + "@img/sharp-win32-x64": + optional: true + checksum: 10/9f153578cb02735359cbcc874f52b56b8074ed997498c35255c7099d4f4f506f6ddf83a437a55242c7ad4f979336660504b6c78e29d6933f4981dedbdae5ce09 + languageName: node + linkType: hard + "shebang-command@npm:^2.0.0": version: 2.0.0 resolution: "shebang-command@npm:2.0.0" @@ -10610,6 +11437,22 @@ __metadata: languageName: node linkType: hard +"simple-swizzle@npm:^0.2.2": + version: 0.2.2 + resolution: "simple-swizzle@npm:0.2.2" + dependencies: + is-arrayish: "npm:^0.3.1" + checksum: 10/c6dffff17aaa383dae7e5c056fbf10cf9855a9f79949f20ee225c04f06ddde56323600e0f3d6797e82d08d006e93761122527438ee9531620031c08c9e0d73cc + languageName: node + linkType: hard + +"simple-wcswidth@npm:^1.0.1": + version: 1.0.1 + resolution: "simple-wcswidth@npm:1.0.1" + checksum: 10/75b1a5a941f516b829e3ae2dd7d15aa03800b38428e3f0272ac718776243e148f3dda0127b6dbd466a0a1e689f42911d64ca30665724691638721c3497015474 + languageName: node + linkType: hard + "sirv@npm:^3.0.0": version: 3.0.0 resolution: "sirv@npm:3.0.0" @@ -11191,7 +12034,7 @@ __metadata: languageName: node linkType: hard -"tar@npm:^7.4.0, tar@npm:^7.4.3": +"tar@npm:^7.0.1, tar@npm:^7.4.0, tar@npm:^7.4.3": version: 7.4.3 resolution: "tar@npm:7.4.3" dependencies: @@ -11645,6 +12488,13 @@ __metadata: languageName: node linkType: hard +"undici-types@npm:~5.26.4": + version: 5.26.5 + resolution: "undici-types@npm:5.26.5" + checksum: 10/0097779d94bc0fd26f0418b3a05472410408877279141ded2bd449167be1aed7ea5b76f756562cb3586a07f251b90799bab22d9019ceba49c037c76445f7cddd + languageName: node + linkType: hard + "undici-types@npm:~6.20.0": version: 6.20.0 resolution: "undici-types@npm:6.20.0" @@ -11770,6 +12620,15 @@ __metadata: languageName: node linkType: hard +"uuid@npm:^10.0.0": + version: 10.0.0 + resolution: "uuid@npm:10.0.0" + bin: + uuid: dist/bin/uuid + checksum: 10/35aa60614811a201ff90f8ca5e9ecb7076a75c3821e17f0f5ff72d44e36c2d35fcbc2ceee9c4ac7317f4cc41895da30e74f3885e30313bee48fda6338f250538 + languageName: node + linkType: hard + "uuid@npm:^9.0.1": version: 9.0.1 resolution: "uuid@npm:9.0.1" @@ -12083,6 +12942,13 @@ __metadata: languageName: node linkType: hard +"web-streams-polyfill@npm:4.0.0-beta.3": + version: 4.0.0-beta.3 + resolution: "web-streams-polyfill@npm:4.0.0-beta.3" + checksum: 10/dcdef67de57d83008f9dc330662b65ba4497315555dd0e4e7bcacb132ffdf8a830eaab8f74ad40a4a44f542461f51223f406e2a446ece1cc29927859b1405853 + languageName: node + linkType: hard + "webextension-polyfill@npm:^0.12.0": version: 0.12.0 resolution: "webextension-polyfill@npm:0.12.0" @@ -12419,7 +13285,7 @@ __metadata: languageName: node linkType: hard -"yaml@npm:^2.6.1": +"yaml@npm:^2.2.1, yaml@npm:^2.6.1": version: 2.7.0 resolution: "yaml@npm:2.7.0" bin: @@ -12501,3 +13367,19 @@ __metadata: checksum: 10/563fbec88bce9716d1044bc98c96c329e1d7a7c503e6f1af68f1ff914adc3ba55ce953c871395e2efecad329f85f1632f51a99c362032940321ff80c42a6f74d languageName: node linkType: hard + +"zod-to-json-schema@npm:^3.22.3": + version: 3.24.1 + resolution: "zod-to-json-schema@npm:3.24.1" + peerDependencies: + zod: ^3.24.1 + checksum: 10/d31fd05b67b428d8e0d5ecad2c3e80a1c2fc370e4c22f9111ffd11cbe05cfcab00f3228f84295830952649d15ea4494ef42c2ee1cbe723c865b13f4cf2b80c09 + languageName: node + linkType: hard + +"zod@npm:^3.22.4": + version: 3.24.1 + resolution: "zod@npm:3.24.1" + checksum: 10/54e25956495dec22acb9399c168c6ba657ff279801a7fcd0530c414d867f1dcca279335e160af9b138dd70c332e17d548be4bc4d2f7eaf627dead50d914fec27 + languageName: node + linkType: hard From 847b1b6a9f99100bb06f07f105ee94a1aad1873b Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 4 Feb 2025 09:13:08 -0600 Subject: [PATCH 33/55] a working rag demo --- packages/nodejs/package.json | 1 + .../src/demo/rag/models/pull-and-make.ts | 39 +++++++++++++++ packages/nodejs/src/demo/rag/run.ts | 3 ++ .../nodejs/src/demo/rag/subclusterConfig.ts | 30 +++++++----- .../nodejs/src/demo/rag/vats/ollama.bundle | 2 +- packages/nodejs/src/demo/rag/vats/ollama.js | 47 +++++++++++++++---- packages/nodejs/src/demo/rag/vats/user.bundle | 2 +- packages/nodejs/src/demo/rag/vats/user.js | 14 +++++- packages/nodejs/src/demo/rag/vats/wiki.bundle | 2 +- packages/nodejs/src/demo/rag/vats/wiki.js | 29 +++++++----- .../src/demo/rag/wiki/ambient-authority.txt | 36 -------------- .../demo/rag/wiki/confused-deputy-problem.txt | 34 +++----------- packages/nodejs/src/vat/vat-worker.ts | 35 ++++++++++---- vitest.config.ts | 8 ++-- yarn.lock | 3 +- 15 files changed, 173 insertions(+), 112 deletions(-) create mode 100644 packages/nodejs/src/demo/rag/models/pull-and-make.ts diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index d9049b92b..a5ec4305f 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -88,6 +88,7 @@ "@langchain/core": "^0.3.37", "@langchain/ollama": "^0.1.5", "@langchain/openai": "^0.4.2", + "@langchain/textsplitters": "^0.1.0", "@ocap/kernel": "workspace:^", "@ocap/shims": "workspace:^", "@ocap/streams": "workspace:^", diff --git a/packages/nodejs/src/demo/rag/models/pull-and-make.ts b/packages/nodejs/src/demo/rag/models/pull-and-make.ts new file mode 100644 index 000000000..4985e1a2c --- /dev/null +++ b/packages/nodejs/src/demo/rag/models/pull-and-make.ts @@ -0,0 +1,39 @@ +import { Ollama } from 'ollama'; + +const ollama = new Ollama({ host: "http://localhost:11434" }); + +const affix8k = '8k'; + +const models = { + llm: ['1.5b', '7b'].map((size) => `deepseek-r1:${size}`), + embeddings: ['mxbai-embed-large'] +}; + +const make8kModel = (model: string) => ollama.create({ + model: `${model}-${affix8k}`, + from: model, + parameters: { + num_ctx: 8096, + }, +}); + +const pull = async (modelsToPull: string[] = [ + ...models.llm, + ...models.embeddings, +]) => { + await Promise.all(modelsToPull.map((model) => ollama.pull({ model }))); +} + +const make8kLLMs = async (modelsToMake: string[] = [ + ...models.llm, + ...models.embeddings, +]) => { + await Promise.all(modelsToMake.map((model) => make8kModel(model))); +} + +export default async function main() { + console.log('pulling models', models); + await pull(); + console.log('making large context models', models.llm); + await make8kLLMs(); +} diff --git a/packages/nodejs/src/demo/rag/run.ts b/packages/nodejs/src/demo/rag/run.ts index 8afae264d..c0ecdbcef 100644 --- a/packages/nodejs/src/demo/rag/run.ts +++ b/packages/nodejs/src/demo/rag/run.ts @@ -8,6 +8,8 @@ import { import { makeKernel } from '../../kernel/make-kernel.js'; import { makeConfig } from './subclusterConfig.js'; +import pullAndMakeModels from './models/pull-and-make.js'; + const ollamaOnline = async () => { const response = await (await fetch('http://localhost:11434')).text(); const expectation = 'Ollama is running'; @@ -23,6 +25,7 @@ main().catch(console.error); */ async function main() { await ollamaOnline(); + // await pullAndMakeModels(); // We don't talk to the Kernel via a console (yet) const kernelPort = new NodeMessageChannel().port1; const kernel: Kernel = await makeKernel(kernelPort); diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts index f5b2b3d96..4e099e1ca 100644 --- a/packages/nodejs/src/demo/rag/subclusterConfig.ts +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -5,23 +5,32 @@ import { readFile } from "fs/promises"; import { join } from "path"; import type { Document } from '@langchain/core/documents'; import type { Json } from "@metamask/utils"; +import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters"; type ModelSize = '1.5b' | '7b' | '8b' | '14b' | '32b' | '70b' | '671b'; type Model = `deepseek-r1:${ModelSize}`; const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; -/* // XXX Todo: RAG in a separate vat, with introduction at bootstrap time. const getWikiContent = async (path: string) => { const resolvedPath = new URL(join('wiki', path), import.meta.url).pathname.replace(/\/dist\//, '/src/'); const loader = new TextLoader(resolvedPath); - return await (await loader.load()).map((document) => ({ - metadata: { source: path }, + const splitter = new RecursiveCharacterTextSplitter({ + chunkSize: 384, + chunkOverlap: 64, + }); + const splitDocs = await splitter.splitDocuments(await loader.load()); + console.log('\n----------'); + console.log('SPLIT DOCS'); + console.log('path:', path); + console.log(JSON.stringify(splitDocs, null, 2)); + console.log('----------\n'); + return splitDocs.map((document) => ({ pageContent: document.pageContent, + metadata: { source: path }, })); } -*/ export const makeConfig = async ( model: Model, @@ -34,28 +43,27 @@ export const makeConfig = async ( bundleSpec: makeBundleSpec('ollama'), parameters: { model, verbose }, }, - /* // A mock wikipedia API which returns the content of a few wikipedia pages. wiki: { bundleSpec: makeBundleSpec('wiki'), parameters: { - docs: [ - ...await getWikiContent('ambient-authority.txt'), - ...await getWikiContent('confused-deputy-problem.txt'), - ], + model: 'mxbai-embed-large' }, }, - */ // The bootstrap vat representing a user action. user: { bundleSpec: makeBundleSpec('user'), parameters: { prompt: [ - 'Describe the confused deputy problem.', + 'Describe the "confused deputy problem".', 'Then, define "object capability model" (OCAP).', 'Finally, explain how OCAP solves the confused deputy problem.', ].join(' '), verbose, + docs: [ + ...await getWikiContent('ambient-authority.txt'), + ...await getWikiContent('confused-deputy-problem.txt'), + ], }, }, }, diff --git a/packages/nodejs/src/demo/rag/vats/ollama.bundle b/packages/nodejs/src/demo/rag/vats/ollama.bundle index 2352105fb..8353d42e8 100644 --- a/packages/nodejs/src/demo/rag/vats/ollama.bundle +++ b/packages/nodejs/src/demo/rag/vats/ollama.bundle @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"dea8b8f3e8e00a772e54bf4033da12b064495c3a868fc2584944f1993b1ca273f6597ac21378a45c5b71b3b31bf4b15fa1582fa75dbf8f5fab508b23e58ff057"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"ee2bc9349fce69083be4927550ffd955d19803a05183e9c7b911f8bdb4d6ab4cfe0ef5d46741b4f8daf57c526891eb754c7a743def387ee6dff124f74896e505"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/ollama.js b/packages/nodejs/src/demo/rag/vats/ollama.js index 755e06d3e..fdf8754d4 100644 --- a/packages/nodejs/src/demo/rag/vats/ollama.js +++ b/packages/nodejs/src/demo/rag/vats/ollama.js @@ -2,13 +2,14 @@ import { E } from '@endo/eventual-send'; import { Far } from '@endo/marshal'; // The default LLM model to use. -const DEFAULT_MODEL = 'deepseek-r1:1.5b'; +const DEFAULT_MODEL = 'deepseek-r1:7b'; const parseResponse = (response) => { const thinkTokens = ['', '']; - const [thought, speech] = response.message.content - .substring(thinkTokens[0].length) - .split(thinkTokens[1]); + const trimmed = response.message.content.startsWith('') + ? response.message.content.substring(thinkTokens[0].length) + : response.message.content; + const [thought, speech] = trimmed.split(thinkTokens[1]); return { thought: thought.trim(), speech: speech.trim(), @@ -31,22 +32,52 @@ export function buildRootObject(vatPowers, parameters, _baggage) { const model = parameters?.model ?? DEFAULT_MODEL; const { verbose } = parameters; const { ollama } = vatPowers; + let thisWiki; console.debug(`buildRootObject "${JSON.stringify({ model, ollama })}"`); return Far('root', { + setWiki(wiki) { + thisWiki = wiki; + }, async chat(prompt) { if (verbose) { console.log('chat'); console.time('llm'); } + const docs = thisWiki + ? await E(thisWiki).retrieve(prompt) + : []; + + console.log('RETRIEVED DOCS', docs); + + const messages = [ + { + role: 'user', + content: [ + 'You may find some or all of the following information helpful when responding to my request.', + ...docs.map(({ pageContent }) => pageContent) + ].join('\n\n') + }, + { role: 'user', content: prompt }, + ]; + + console.log('\n--------'); + console.log('MESSAGES') + console.log(JSON.stringify(messages, null, 2)); + console.log('--------\n'); + const response = await ollama.chat({ - model, - messages: [ - { role: 'user', content: prompt } - ], + model: `${model}-8k`, + messages, }); const { thought, speech } = parseResponse(response); + + console.log('\n--------'); + console.log('THOUGHTS'); + console.log(JSON.stringify(thought.split('\n\n'), null, 2)); + console.log('--------\n'); + if (verbose) { console.timeEnd('llm'); console.debug('Thought:', thought); diff --git a/packages/nodejs/src/demo/rag/vats/user.bundle b/packages/nodejs/src/demo/rag/vats/user.bundle index 5cd17260c..34f4976e9 100644 --- a/packages/nodejs/src/demo/rag/vats/user.bundle +++ b/packages/nodejs/src/demo/rag/vats/user.bundle @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"55b4ea59fa5b63ae43ebefe066665276b724d6166b5fc31e18689370fa0f8baa9a23a58e9680551dfa136bee665ea6727537867a764ea1a191dbecd43aa6cd32"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"3c03f7da98cef4668100d78ab7342043af3e9f6a8a18fe8e28859eb77984b5c292f7e2c49dde9dc2aa4f933c4af6e04019a92ae033c9751fdf48df2cbf72390c"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js index ec7d1555c..d258541b1 100644 --- a/packages/nodejs/src/demo/rag/vats/user.js +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -9,15 +9,21 @@ import { Far } from '@endo/marshal'; * @param {unknown} _baggage - Root of vat's persistent state (not used here). * @returns {unknown} The root object for the new vat. */ -export function buildRootObject(_vatPowers, parameters, _baggage) { +export function buildRootObject(vatPowers, parameters, _baggage) { const prompt = parameters?.prompt ?? `Say hello.`; - const { verbose } = parameters; + const { verbose, docs } = parameters; return Far('root', { async bootstrap(vats) { if (verbose) { console.log('Bootstrap') } + + console.log('initializing:', 'wiki'); + await E(vats.wiki).initModels(); + await E(vats.wiki).addDocuments(docs); + console.log('initialized:', 'wiki') + console.log([ '', '-----\nUSER:\n-----', @@ -25,7 +31,10 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { '-----', '', ].join('\n\n')); + + await E(vats.ollama).setWiki(vats.wiki); const response = E(vats.ollama).chat(prompt); + console.log([ '', '----\nLLM:\n----', @@ -33,6 +42,7 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { '----', '', ].join('\n\n')); + }, }); } diff --git a/packages/nodejs/src/demo/rag/vats/wiki.bundle b/packages/nodejs/src/demo/rag/vats/wiki.bundle index a44054c1e..869227cea 100644 --- a/packages/nodejs/src/demo/rag/vats/wiki.bundle +++ b/packages/nodejs/src/demo/rag/vats/wiki.bundle @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAAAkLaOZCzsAAAs7AAAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgInRhZ3MiOiBbXSwKICAiZW50cnkiOiB7CiAgICAiY29tcGFydG1lbnQiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAibW9kdWxlIjogIi4vc3JjL2RlbW8vcmFnL3ZhdHMvd2lraS5qcyIKICB9LAogICJjb21wYXJ0bWVudHMiOiB7CiAgICAiQGVuZG8vY29tbW9uLXYxLjIuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vY29tbW9uIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2NvbW1vbi12MS4yLjgiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vY29tbW9uLXYxLjIuOCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL29iamVjdC1tYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAib2JqZWN0LW1hcC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjEwZTA4YzE4NzZiODQzYzFmMDAyNzdmNmQzNGRkYTNiZDkzMjlkZTZhOWYwOTMxMzU4MjAxZjEwMDRjMmYzYTY0MTg5ZjZmZjBlYWJmZjhiYzU2MjRkNDAyYzFlN2M1NzJlNmFhM2JlYmI5MzM4ZjIzNzVmM2Y4MzFhYmEzOGYyIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2Vudi1vcHRpb25zIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQxNzc2ZWViMjFiMWM1NTFkYTNmOWI4ZGNkZjVhYmQ4OGJjYmY1ZjhlMzhjYjA0ZWRhYmM4Y2I5NjRiYjk3NTE4ZmY0Y2FjYjc0M2U4YWJiYWFjMjI4NjE2ODE1ZmJlNDBlODZiZTJkN2Q0MjgxNTc4OTUyZjhhYTg2NmExYjk3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vudi1vcHRpb25zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbnYtb3B0aW9ucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjljZWIxMmRlNmQ2MWE2MzQwNzg1NTI4NmU1ZTEwNzgzYjUyZDUzNGIxNWVlYjY0OWI5ZTU2MWQxMDY3MDc0ODUxOTJlOTc5MTQxYjQyMjU5ZTY0Njk5YjY2MWI4OTNmNDQyNDVkMTFjNGFhYTA3MGUxOTM4NDBmM2I3ZWQxYWU0IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lcnJvcnMtdjEuMi44IjogewogICAgICAibmFtZSI6ICJAZW5kby9lcnJvcnMiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxZmQ0MTdiY2RiZGFlYzY5ZGExYWRkZWJiNTFmNjU5YmI4YjMxNWRjMWM5NmI3ZjcxMTU2YzU1NjJmMTdjZDkxOGNjYTA5ZGJmMDIxMmNjYmUxMWRkOTBhYjMzYTUxYjlkMTllYTMzY2ExOTNkMTY2NTI0ZTczYjMyYmEzNTVjMiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmM5ZDk3ZDA3OTRlYWU4NjhmM2Q2Y2RhYjFkNWNiYjk1ZmU1NjZlYzBhYThmMzFmYzdkNzhlMTBkOTUzNTllYjE2MmQ2NjE4ODIyZWEyMDVkYjUyYzI1ZGZiOTY4MGYxZDA5MGZmYjFmNGE0ZWM4Y2YxYmZhODM1ZjY1ZDZiYjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZXhwb3J0cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXhwb3J0cy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xvY2FsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9sb2NhbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk2YTQ4MWI2M2NjMzQxMDU0NTBhYWI0M2E2ZmJiNDAwYTYyNTdhMDgzN2VjMzMzZDM1ODJkMDIyNDJkYzg1MDgzZWUyYjFkOWZjM2RkMTBjOWEyNDg2MmU1NmUyNDkxODEyY2UxN2ZkMDMzNGM2MWFmNGZiMjA5ZjNmN2Y2YTQzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzc4YmJjYjcxNWVmOTM5ZGZmNjdhNTI2YzlhMGIyMmEwYTMyMDBkMTBjOTczZDhkYzFlZWI5N2NmNTY4NTVlNDk2ZDNiODg0Mjc2NGMyMTRlZGU1MWUxZGJlMjUzNzVkYTAxMjFhNjg4ZjNiOGMxZDFmN2M5YTYzYzE0ZDM2MSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9uby1zaGltLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9uby1zaGltLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGFjNWNiYjQ0N2NjNTk5ZDUxYTk2NGUyODVlMjljMDliYmI5MDdkNzJhYjY1MzNhMmQ5MzJmNTFjYzc4NWMwY2ZmOTMwMDNjNWJmNWRiMTE2MWQzNWMzY2ZhM2JmNTJhNGI4OGM4NjVjZTVmYjg0ZjU4MzIzNjczNWJmNWFiMjgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHJhY2stdHVybnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RyYWNrLXR1cm5zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2IwMjE3N2Y1NDVmNWE2Y2ExNDRiOGVhM2M4MzJjODk4NzExZThlYTJjZjU0Mzk1OWY1YTViYjcxMjRlNWYwNDdlNDljMDFkOGY1MThkNThkMDAzY2ZhZDQyODY3NGRjNDVkNWY1MTBlNGE0ZjRiNTE0ZGNkNWE3NTFjM2U1NmYiCiAgICAgICAgfSwKICAgICAgICAiLi91dGlscy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJ1dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImZlYTA0MTFiMjE2YzcxNDE1MTQzOTY2NjRmOGY4MjEzYWNkMTEyZTkzMGMwZjRmYWMwMzQyN2Y1NzM3ZDczN2QwZTk0NmI2Y2M0YzYwODg0ZDA0MDU3Yjc3Zjg4MDhhMzk2NzM2ODU5NTU4ODcyNDM1ZWFlZWVkMmYxMzI2NDdkIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9tYXJzaGFsLXYxLjYuMiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbWFyc2hhbCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jb21tb24tdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9vYmplY3QtbWFwLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Vycm9ycyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY1LjAuMTMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5NzFhNGJhZjkyYjU0OGUyNDc0ODgwYzA3ZGFiZjM2MWYyZmQwMzhjNDAwZGE1MWQwYTQ0NjgwOTJlMzY1NTU3Njk3YzhlYjFjYWUzMjVjZmQ5ZmFmNzJhYjg2YzEzZjA0MjQwYTZlMTQ3M2E3ZTM5Mzg2MmRkMDQxMWI1NGUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVBhc3NhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjBkYWNmYTE3YTA1ZmU0M2IwY2FkY2QxODYzMGRiZjU4NmJkMjRkYTQ0YTc4ODU5MDAyNTUxMWVkOGRlZmEwZjEyOWQ3YjI0M2I1YjljZjA2MzAzZTQxNGNlN2I3NzZmOTA4NzgwZDE1NGJkOTI4NTU3MDFhOTgyMGQxMWQ5MWIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb0NhcERhdGEuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlMjEzNzVlYzUxNGEyYjAxMDVjYzJmYmRlY2IzNWJiNTE5OWIyMmZmZjY5MjkwOWIzNGM4NGJmYzE2ZDc5OTBlZjVkMzQyY2I1ZjAyYzZhMzI1N2IwN2E4Y2EzNjJjNmEyMzE1MjJiODg5ZjgxZDQ2ODVhNDYwN2ZiZDg0OTcwYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlVG9TbWFsbGNhcHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNTU4Y2EwZTNhOTcwZjQzZWRlYzdhOTY5NTA2YmQ4MWU0ZDllZmNkOWVlZGFjZDg3NDcyZTFmYzQ1ZDAyMmFlZDAzZjcxMmJjYTUxYTJkN2VjMTQ5MjllNWZlMDg4MjM2NDM3OTIwNDEzYjM1Y2EwZjk4NTdlZjExODE2ZmNmNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1qdXN0aW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2ZTQxOTY2OWYyN2RmMjI1MWUwMWNlMTU4NmVkYzVmNzI0YjNjNjgxOTM5MzE2NjA2ZDU0OWRmY2ZjOTllMDk2MjZjMTllNDY3MGY0ZDc1MmM3OTRiMGYxOTczOTFjYzBiZDM3NTdjYzNkYWVkZGE5NzJkN2Y0NTY4MmQzZWYxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0NGNmNmRiZWY1MzliYjQ5YTdhZTFlODkzZGZmNGVlYmQ4NWJmNzE4MTdhZDczODg1YzUxMmY4NjBhZWFmOTJlNzQ3ZWZlMzg2N2ExZjg4YzY4YTFiMmYwMjc5YjRiNmE0MjQzMWYwNWMzNWEzNTdhM2ZlMzdhNjRjMTY1YmQzOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYTdlMzgxYjcxNDBkNTM5Y2U2Yjg0NThlYWU3ZTcyZjM4ZTUyNDgxMjhhYmYyMWU5ZjU2OGI1NDY0ODlhMjYzY2JkYWNhMmIzNGE0NTcxNDgyNzA4OWI3NDk3MzgwZDNhYTA2NjY5YjVkZGE3NjhkMzljODE5YjhkODdlM2NlYzgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmFua09yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yYW5rT3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwOTY2MzNlODZjMDk2ZmYzMjhlMjM0NDJmYWU0ZWVhZWJkNjlmNDhlODQzM2RkOTlkODU0YmJkOGI3MDM3YzgzNjM0MmRiNjI4OTYzYWFjYTE5YzIxNzIwMTViNjhjZjk5MWJmMTRiMTVhM2IwOWYzM2YwMGEzZDI0ZWJlZTEyNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1NDY1NWU4NTkzMTk4ODQ3MGJkZGFiMWZlZjU1NmVmOGJmYjdlMjYyNTBiNmVlZTQ1NTYwZDgwZWQxZTNlZjhkNWJiOGU1ZDA1OGI2MDg1ZWNlMmUxN2FmMjE2ZDgzYWE5MzkwNzBlNGUyYzE5NTI1ODk4NmI3MzYwOTlmYWQ5YyIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vbmF0LXY1LjAuMTMiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL25hdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzQyZTI2NjMyYmJhYjRiYzhmNTkxN2Q3MmYwNzQyM2MxNjI2NGYyZDZhMjBmNmRlOGQxODk2NjZhM2VmMTk2NjhiNmJkNTdlZTYzODM1MmY4OGQ5YzY5Mjk5OGFmZTY4YjUxM2E4YzMzYmY2ODJkODZhZmUwM2ExZTEzYTdlYiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Bhc3Mtc3R5bGUiLAogICAgICAibGFiZWwiOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9lcnJvcnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdXRpbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5MzJkNTRmNWI0MWFjN2IyNDFiMDQ0N2RlYmI1Zjc5MzU5YTRjYWM1MmQ3Y2I2ODQ1NTRkMjUxNTE5OWI5OWE0NWYwMWZlYzkyYWNhNDdhYTViNzE1OWU0ZWRiOTRhYzdjYzRiMWJhODYxNWIyMzk0NDI4ODFlZDg5MGZlMTUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29weUFycmF5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5QXJyYXkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMTk4YTI4ODUyYjRjYTM2OGJmODdmYTg0ZDcwYmM3YmNmOTUwZGM1Y2Y2MzUyYWY2YzFhOTg3YzE2ZTc3NDkxMDQ4NTFhNDUyMGMxZjMyNzZiZDk1ZDIwZGEyNzU4ZTRhNDM0MWUwOTI4NjQ4YzlmY2QzOTBjNDRhZGMyMjQ0MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb3B5UmVjb3JkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5UmVjb3JkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmExMTgzYzI4ZmU1N2MyNjM3MmZhNWI5NDRhMzg1NzZkNWRhNmQ5MzIwYWZmNzY0YWFlODkxNjRhNWEwNGE1NzNmYWI5ZGRiOWY2YzJjZTk2NWUxMjFkYmRmYWNkYWM0MzE0NDMzOWUzODM4MzY4YzkyMWI0YjY3YTNlZjgzOTgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9kZWVwbHlGdWxmaWxsZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5MDY3Yjc1OWYyNGQ0OWEzOTc4Y2M5NGQzMDZiNjJlZDFlZmQyM2M3NmU0YzFhMjI2NDhjMzVhN2NkMjcxZTg1ZTYzZGNmNTNhZjdmNWZhMjA3YjNlMzQ5YjgwNTdkYzBjMjM5OTcwNjgwNTNlZmE5YzZmYzY5N2Q0YzBlNWQzYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lcnJvci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXJyb3IuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyNGViNDFhZmI3OTc2YmI3YTNmNDVkMjk1NGVlY2FhNWEzMzIwN2ZmMzBiNjhmMGEzZDcxZGJkNWY0ZWU1MDQ1ZTg4NzA4MmY1OGYwNDM2MTgxOTZkMzA5YjFlNTUyNTMxMjVlMjBiYmRiMjJmYTAyNzgyYTE0ZWRjM2JlNGZmMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pdGVyLWhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2l0ZXItaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdlNGM5NjA4ZDE1ZDYzYTdjYzc1ODIyYWE3MGRiNGE3NzMwZjMyZTBjYzZhYTRiZDNiOTAwYjA1Mjk4ZTU3YjE1NTljOTY1YjU0OTJlNGE4NWY4YTIwYTc2N2RmZjJlMTcwNThkMDg3NTEzYzY4NTI2MGY0NWNmOTJiYjIwY2RjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2UtZmFyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYWtlLWZhci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjUyNmU2OTgxMzc1MjE4ZDA3YmZlNWMzYjhjMjg3ZGMyMDVlYTBkNTU5NjRjYmMyMWJjYWZiNzMxOWE2YTg5MGRkNTU1M2ViZmRjN2EzMjM2MTQxYTFkNzVlNzVhOTcyOGUwMzUyZTc2NTU0N2E0NDI3OWE1ZGNmN2EzYjVlYzU3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2VUYWdnZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2VUYWdnZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4YTU3ZjRmMTg3MTE0NjhkODFlMzBlODJiYzYwZTQ3MDQyMDI2ODFmMjY5NGFkM2IwNzUzY2IzYmQyMWNmOWQ0OWQ3OGYyNzliYWU0ZjlkMTI5Njg3MzJkNDYxOTU1ODZkOTcyNzNhZGFmNGQ3NmY4ZWJmNDA4MjQyM2IwMTgxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNGJmMmNkNjVlYTI1NGVlYjMyZWQ4MDI5ZTEzNTBkOGE4MTJiM2EzM2VkMGMyYzkxYzcxZDhjNzRhOTlmYWZhM2UwMjIwMTAzZjY5NWIwN2RiMTYxMjI3YWJhNjNhMWE5YWIwNzU4N2M0NTNhNThhMDA5Yjk0NWQ0MjFmZTJiMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGVPZi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlT2YuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjYTI3NTA3YzU4MjhmMzQ3ZWFmMmYyNzVkNjY5NzEyNDVlYmUyZGRlNjk0NjMwODJjMjE1ZTc3ZDAyNjZmZThmZjBjYTA4MTQwZjk4ZTljNDIyYTAxNjJlNjc3MTE3YzkwNGM5MzczNzRiNmUzNTNiYjVhODA3NzU1MGEzZTQwMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yZW1vdGFibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JlbW90YWJsZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc0MWU1ODdkYmJmNTY4OTRhMDFmNzdhMmNlM2RmOTBmZGQ5MmNjN2RiMDExMDY0MmY5NDY0NGQ2NTRhZTI3MmIzZTRmZjFkODEwNGMzZWI5NmIxMzI0ODg3YzdkNjhiMzQxNjEyODI3ZDAzMTQxOGU5OGI3NjM0Y2M5MDE0M2VkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3NhZmUtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc2FmZS1wcm9taXNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjE4YjZmYWJlODY3MzRmMWU5ZTEwZTkyMjA1MWY3MGYyMzY4ODFiMWZlODg5YjI2MTQ1OTY4ZjBiYThiNmQ4ZGEwZTAyMjk4MDk5ZGY2OGM1YzA1MjViZGY5NDUwYTkyOTdkM2Q5MjY3ZjczNjk2NDIwOGJkYzM5YTAwNjNlMjciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RyaW5nLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zdHJpbmcuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNWY4ZjYwZGEzNzVjNGRkNTQ1YWY2MTEwYzY2OWM0MDI0ODI2YzIwZWIxYWU4ZDkyYTNiMDEyNzVjN2Q2Y2VhM2RhZDZiOTI0MjVlNjAzZTQ2NzczZWM3MzA2NTM1OWE2MThjNTdlYWJiMTVlNWZhOTA5MWNmYjJkMDMxNjEwZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zeW1ib2wuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N5bWJvbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImM1Mzc0MDgxNDdhNzIzOGRlZDFjMzczZTZlZTZiYWYzNDNkYTdkMmM0YzU5NTJmMjMwMjU2MDFlNThlNTdmMjJiMzI1OWZhMDIyYWNlNjk0YjVjMjg5MDY3ZGIxZmZkZmQyMjk2NDJmYzBiMzlkOTcxNmJmZmE5MGVmMjJkZjBkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdGFnZ2VkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjU3NWQxNDUxZjQ3ZWIzZDg4YzU0MzVkZTE5NGUwZjc2M2Q3NDc2M2EzMzE3YzNhYTE1Zjc2ZjQ1MjQzY2E5MTA2NmViYzk2YWYxZTk3MjA0MDNkYWVlZmRiMjU4NmY3MzFiZWVhMjM0MzBmMDg3Njc3ZDQzZjFlM2RjNWMyZjAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5YzdhOWM0NGUxY2MxNmM1Nzg1N2NjNzJkZjgxMWY5YjZjMjZlYzllNjMwZDhiYjEzMWFiYmU4NWUyZjQ3OWQxMTJhNDU0N2YyNDAxNzk0Nzg2MTNjZjk3ZTQ1NDE4MzAwN2FjNTQ4MDBiMWE4ZDU2MTc4ZjE4ODBlYWMwNWE2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Byb21pc2Uta2l0IiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImFmNDk2MmU0ODNkODRjODdmZDliNzk1ZDdkM2ViYzRkZTIwM2Y5NGQ1MDQxODhjY2VmNDFmZjA5ZGUwYmVmNTI1NDNmNGYzMTNjYTE5ZWMxN2ZjYzRiOGNkODg3NzhhYWQ2ZjY0YzgxMDFkODM3NDc4ZDhiNTk0YTEwNjZjOTdjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2lzLXByb21pc2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2lzLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NzczMTVhNTE2MjM1YTAyMDQ4YjNjNGRmMTA3MWM4YmYxZjFkZTkwM2Q0Y2U4YTkyYzk1OGUxZTBjNzI2NGVkZDIyZjU3NjE5OWYyZjEzOWViMWZkNjI3MDVhODUzNmU3NTAyZTM4ODZjYTNmNWYyODkzMTI0YmU4M2E0YzlhNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tZW1vLXJhY2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lbW8tcmFjZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY0ZWZjOGY0ZGE2MDBhMzEyNmQyN2NkNTBhYjAxNzAyNTAzMGMyZjI0Yzk5YWExODFiNTJhODRkZDEzNGIxODcxNjkxMzVlNjZlZjJlYjYzNjMwYmVmNzYwNzQ4MzM3NzdjNDUzMGYyM2E5NDdhMzNkYzg1MDMyN2YxNTQzOGNlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjRlMmM0YjVjZGUzOGUxZjQ2ZmNiMDAxYTQyNzQ1YTgyMzIxNDhlNTMxZDc2ZWM5NmE2YWM5NmNhODVlNjE4MDM1MjgyNzE5MzAxNTUzMGU2ZjUyYzQ5NTFjN2Y1NmEzYWRiNjFmNjlmMmM1OWU1NzEyZGE5NjY1MThiMzk3OTc1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAb2NhcC9ub2RlanMtdjAuMC4wIjogewogICAgICAibmFtZSI6ICJAb2NhcC9ub2RlanMiLAogICAgICAibGFiZWwiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAb2NhcC9ub2RlanMtdjAuMC4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MS42LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlbW8vcmFnL3ZhdHMvd2lraS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGVtby9yYWcvdmF0cy93aWtpLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYWRmMDUwNzBjNDg1NDA1YWY1ODcwYTcyNjQ1NjIwYmJmMDk2MmI4NzNjY2Q3N2MyYTUzNjdlYTQzMWY4ZmNjZmJlZGFmNzllMzcwNTJlZTU0MmRlODFmMDBmOTZjMmQ2ZjZlNGEwNzE3YWZlNTQxYzJiNDc3ODU2ZmM4NTlhMjAiCiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9UEsDBAoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAQGVuZG8vY29tbW9uLXYxLjIuOC9vYmplY3QtbWFwLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJvYmplY3RNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIGNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBCeSBhbmFsb2d5IHdpdGggaG93IGBBcnJheS5wcm90b3R5cGUubWFwYCB3aWxsIG1hcCB0aGUgZWxlbWVudHMgb2ZcbiAqIGFuIGFycmF5IHRvIHRyYW5zZm9ybWVkIGVsZW1lbnRzIG9mIGFuIGFycmF5IG9mIHRoZSBzYW1lIHNoYXBlLFxuICogYG9iamVjdE1hcGAgd2lsbCBkbyBsaWtld2lzZSBmb3IgdGhlIHN0cmluZy1uYW1lZCBvd24gZW51bWVyYWJsZVxuICogcHJvcGVydGllcyBvZiBhbiBvYmplY3QuXG4gKlxuICogVHlwaWNhbCB1c2FnZSBhcHBsaWVzIGBvYmplY3RNYXBgIHRvIGEgQ29weVJlY29yZCwgaS5lLixcbiAqIGFuIG9iamVjdCBmb3Igd2hpY2ggYHBhc3NTdHlsZU9mKG9yaWdpbmFsKSA9PT0gJ2NvcHlSZWNvcmQnYC4gRm9yIHRoZXNlLFxuICogbm9uZSBvZiB0aGUgZm9sbG93aW5nIGVkZ2UgY2FzZXMgYXJpc2UuIFRoZSByZXN1bHQgd2lsbCBiZSBhIENvcHlSZWNvcmRcbiAqIHdpdGggZXhhY3RseSB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lcywgd2hvc2UgdmFsdWVzIGFyZSB0aGUgbWFwcGVkIGZvcm0gb2ZcbiAqIHRoZSBvcmlnaW5hbCdzIHZhbHVlcy5cbiAqXG4gKiBXaGVuIHRoZSBvcmlnaW5hbCBpcyBub3QgYSBDb3B5UmVjb3JkLCBzb21lIGVkZ2UgY2FzZXMgdG8gYmUgYXdhcmUgb2ZcbiAqICAgICogTm8gbWF0dGVyIGhvdyBtdXRhYmxlIHRoZSBvcmlnaW5hbCBvYmplY3QsIHRoZSByZXR1cm5lZCBvYmplY3QgaXNcbiAqICAgICAgaGFyZGVuZWQuXG4gKiAgICAqIE9ubHkgdGhlIHN0cmluZy1uYW1lZCBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIG9mIHRoZSBvcmlnaW5hbFxuICogICAgICBhcmUgbWFwcGVkLiBBbGwgb3RoZXIgcHJvcGVydGllcyBhcmUgaWdub3JlZC5cbiAqICAgICogSWYgYW55IG9mIHRoZSBvcmlnaW5hbCBwcm9wZXJ0aWVzIHdlcmUgYWNjZXNzb3JzLCBgT2JqZWN0LmVudHJpZXNgXG4gKiAgICAgIHdpbGwgY2F1c2UgaXRzIGBnZXR0ZXJgIHRvIGJlIGNhbGxlZCBhbmQgd2lsbCB1c2UgdGhlIHJlc3VsdGluZ1xuICogICAgICB2YWx1ZS5cbiAqICAgICogTm8gbWF0dGVyIHdoZXRoZXIgdGhlIG9yaWdpbmFsIHByb3BlcnR5IHdhcyBhbiBhY2Nlc3Nvciwgd3JpdGFibGUsXG4gKiAgICAgIG9yIGNvbmZpZ3VyYWJsZSwgYWxsIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogICAgICBub24td3JpdGFibGUsIG5vbi1jb25maWd1cmFibGUsIGRhdGEgcHJvcGVydGllcy5cbiAqICAgICogTm8gbWF0dGVyIHdoYXQgdGhlIG9yaWdpbmFsIG9iamVjdCBtYXkgaGF2ZSBpbmhlcml0ZWQgZnJvbSwgYW5kXG4gKiAgICAgIG5vIG1hdHRlciB3aGV0aGVyIGl0IHdhcyBhIHNwZWNpYWwga2luZCBvZiBvYmplY3Qgc3VjaCBhcyBhbiBhcnJheSxcbiAqICAgICAgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGFsd2F5cyBiZSBhIHBsYWluIG9iamVjdCBpbmhlcml0aW5nIGRpcmVjdGx5XG4gKiAgICAgIGZyb20gYE9iamVjdC5wcm90b3R5cGVgIGFuZCB3aG9zZSBzdGF0ZSBpcyBvbmx5IHRoZXNlIG5ldyBtYXBwZWRcbiAqICAgICAgb3duIHByb3BlcnRpZXMuXG4gKlxuICogV2l0aCB0aGVzZSBkaWZmZXJlbmNlcywgZXZlbiBpZiB0aGUgb3JpZ2luYWwgb2JqZWN0IHdhcyBub3QgYSBDb3B5UmVjb3JkLFxuICogaWYgYWxsIHRoZSBtYXBwZWQgdmFsdWVzIGFyZSBQYXNzYWJsZSwgdGhlbiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqIGEgQ29weVJlY29yZC5cbiAqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIGFueT59IE9cbiAqIEB0ZW1wbGF0ZSBSIG1hcCByZXN1bHRcbiAqIEBwYXJhbSB7T30gb3JpZ2luYWxcbiAqIEBwYXJhbSB7KHZhbHVlOiBPW2tleW9mIE9dLCBrZXk6IGtleW9mIE8pID0+IFJ9IG1hcEZuXG4gKiBAcmV0dXJucyB7UmVjb3JkPGtleW9mIE8sIFI+fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKFxuKFtrLHZdKT0+LyoqIEB0eXBlIHtba2V5b2YgTywgUl19ICovW2ssbWFwRm4odixrKV0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7UmVjb3JkPGtleW9mIE8sIFI+fSAqL2hhcmRlbihmcm9tRW50cmllcyhtYXBFbnRzKSkpO1xuIH07JGjNj19vbmNlLm9iamVjdE1hcChvYmplY3RNYXApO1xuaGFyZGVuKG9iamVjdE1hcCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJvYmplY3RNYXAiOlsib2JqZWN0TWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUY5zqUAQAAlAEAACEAAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW52LW9wdGlvbnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy9lbnYtb3B0aW9ucy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvZW52LW9wdGlvbnMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAXZuU6h4TAAAeEwAAKwAAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiLCJnZXRFbnZpcm9ubWVudE9wdGlvbiIsImdldEVudmlyb25tZW50T3B0aW9uc0xpc3QiLCJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtY2hlY2sqL1xuXG4vKiBgQGVuZG8vZW52LW9wdGlvbnNgIG5lZWRzIHRvIGJlIGltcG9ydGVkIHF1aXRlIGVhcmx5LCBhbmQgc28gc2hvdWxkKi9cbi8qIGF2b2lkIGltcG9ydGluZyBmcm9tIHNlcyBvciBhbnl0aGluZyB0aGF0IGRlcGVuZHMgb24gc2VzLiovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cbi8qIFByZWx1ZGUgb2YgY2hlYXAgZ29vZCAtIGVub3VnaCBpbWl0YXRpb25zIG9mIHRoaW5ncyB3ZSdkIHVzZSBvciovXG4vKiBkbyBkaWZmZXJlbnRseSBpZiB3ZSBjb3VsZCBkZXBlbmQgb24gc2VzKi9cblxuY29uc3R7ZnJlZXplfT1PYmplY3Q7XG5jb25zdHthcHBseX09UmVmbGVjdDtcblxuLyogU2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gdGhlIG9uZSBpbiBzZXMnIGNvbW1vbnMuanMgZXZlbiB0aG91Z2ggaXQqL1xuLyogdXNlcyB0aGUgb3RoZXIgdGVjaG5pcXVlLiovXG5jb25zdCB1bmN1cnJ5VGhpcz1cbihmbik9PlxuKHJlY2VpdmVyLC4uLmFyZ3MpPT5cbmFwcGx5KGZuLHJlY2VpdmVyLGFyZ3MpO1xuY29uc3QgYXJyYXlQdXNoPXVuY3VycnlUaGlzKEFycmF5LnByb3RvdHlwZS5wdXNoKTtcbmNvbnN0IGFycmF5SW5jbHVkZXM9dW5jdXJyeVRoaXMoQXJyYXkucHJvdG90eXBlLmluY2x1ZGVzKTtcbmNvbnN0IHN0cmluZ1NwbGl0PXVuY3VycnlUaGlzKFN0cmluZy5wcm90b3R5cGUuc3BsaXQpO1xuXG5jb25zdCBxPUpTT04uc3RyaW5naWZ5O1xuXG5jb25zdCBGYWlsPShsaXRlcmFscywuLi5hcmdzKT0+e1xubGV0IG1zZz1saXRlcmFsc1swXTtcbmZvcihsZXQgaT0wO2k8YXJncy5sZW5ndGg7aSs9MSl7XG5tc2c9IGAke21zZ30ke2FyZ3NbaV19JHtsaXRlcmFsc1tpKzFdfWA7XG4gfVxudGhyb3cgRXJyb3IobXNnKTtcbiB9O1xuXG4vKiBlbmQgcHJlbHVkZSovXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogYG1ha2VFbnZpcm9ubWVudENhcHRvcmAgcHJvdmlkZXMgYSBtZWNoYW5pc20gZm9yIGdldHRpbmcgZW52aXJvbm1lbnRcbiAqIHZhcmlhYmxlcywgaWYgdGhleSBhcmUgbmVlZGVkLCBhbmQgYSB3YXkgdG8gY2F0YWxvZyB0aGUgbmFtZXMgb2YgYWxsXG4gKiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQgd2VyZSBjYXB0dXJlZC5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gYUdsb2JhbFxuICogQHBhcmFtIHtib29sZWFufSBbZHJvcE5hbWVzXSBEZWZhdWx0cyB0byBmYWxzZS4gSWYgdHJ1ZSwgZG9uJ3QgdHJhY2tcbiAqIG5hbWVzIHVzZWQuXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW52aXJvbm1lbnRDYXB0b3I9KGFHbG9iYWwsZHJvcE5hbWVzPWZhbHNlKT0+e1xuY29uc3QgY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzPVtdO1xuXG4vKipcbiAqIEdldHMgYW4gZW52aXJvbm1lbnQgb3B0aW9uIGJ5IG5hbWUgYW5kIHJldHVybnMgdGhlIG9wdGlvbiB2YWx1ZSBvciB0aGVcbiAqIGdpdmVuIGRlZmF1bHQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbk5hbWVcbiAqIEBwYXJhbSB7c3RyaW5nfSBkZWZhdWx0U2V0dGluZ1xuICogQHBhcmFtIHtzdHJpbmdbXX0gW29wdE90aGVyVmFsdWVzXVxuICogSWYgcHJvdmlkZWQsIHRoZSBvcHRpb24gdmFsdWUgbXVzdCBiZSBpbmNsdWRlZCBvciBtYXRjaCBgZGVmYXVsdFNldHRpbmdgLlxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZ2V0RW52aXJvbm1lbnRPcHRpb249KFxub3B0aW9uTmFtZSxcbmRlZmF1bHRTZXR0aW5nLFxub3B0T3RoZXJWYWx1ZXM9dW5kZWZpbmVkKT0+XG57XG50eXBlb2Ygb3B0aW9uTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYEVudmlyb25tZW50IG9wdGlvbiBuYW1lICR7cShvcHRpb25OYW1lKX0gbXVzdCBiZSBhIHN0cmluZy5gO1xudHlwZW9mIGRlZmF1bHRTZXR0aW5nPT09J3N0cmluZyd8fFxuRmFpbCBgRW52aXJvbm1lbnQgb3B0aW9uIGRlZmF1bHQgc2V0dGluZyAke3EoXG5kZWZhdWx0U2V0dGluZylcbiB9IG11c3QgYmUgYSBzdHJpbmcuYDtcblxuLyoqIEB0eXBlIHtzdHJpbmd9ICovXG5sZXQgc2V0dGluZz1kZWZhdWx0U2V0dGluZztcbmNvbnN0IGdsb2JhbFByb2Nlc3M9YUdsb2JhbC5wcm9jZXNzfHx1bmRlZmluZWQ7XG5jb25zdCBnbG9iYWxFbnY9XG50eXBlb2YgZ2xvYmFsUHJvY2Vzcz09PSdvYmplY3QnJiZnbG9iYWxQcm9jZXNzLmVudnx8dW5kZWZpbmVkO1xuaWYodHlwZW9mIGdsb2JhbEVudj09PSdvYmplY3QnKXtcbmlmKG9wdGlvbk5hbWUgaW4gZ2xvYmFsRW52KXtcbmlmKCFkcm9wTmFtZXMpe1xuYXJyYXlQdXNoKGNhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcyxvcHRpb25OYW1lKTtcbiB9XG5jb25zdCBvcHRpb25WYWx1ZT1nbG9iYWxFbnZbb3B0aW9uTmFtZV07XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2Ygb3B0aW9uVmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gbmFtZWQgJHtxKFxub3B0aW9uTmFtZSlcbiB9LCBpZiBwcmVzZW50LCBtdXN0IGhhdmUgYSBjb3JyZXNwb25kaW5nIHN0cmluZyB2YWx1ZSwgZ290ICR7cShcbm9wdGlvblZhbHVlKVxuIH1gO1xuc2V0dGluZz1vcHRpb25WYWx1ZTtcbiB9XG4gfVxub3B0T3RoZXJWYWx1ZXM9PT11bmRlZmluZWR8fFxuc2V0dGluZz09PWRlZmF1bHRTZXR0aW5nfHxcbmFycmF5SW5jbHVkZXMob3B0T3RoZXJWYWx1ZXMsc2V0dGluZyl8fFxuRmFpbCBgVW5yZWNvZ25pemVkICR7cShvcHRpb25OYW1lKX0gdmFsdWUgJHtxKFxuc2V0dGluZylcbiB9LiBFeHBlY3RlZCBvbmUgb2YgJHtxKFtkZWZhdWx0U2V0dGluZywuLi5vcHRPdGhlclZhbHVlc10pfWA7XG5yZXR1cm4gc2V0dGluZztcbiB9O1xuZnJlZXplKGdldEVudmlyb25tZW50T3B0aW9uKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5jb25zdCBnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0PShvcHRpb25OYW1lKT0+e1xuY29uc3Qgb3B0aW9uPWdldEVudmlyb25tZW50T3B0aW9uKG9wdGlvbk5hbWUsJycpO1xucmV0dXJuIGZyZWV6ZShvcHRpb249PT0nJz9bXTpzdHJpbmdTcGxpdChvcHRpb24sJywnKSk7XG4gfTtcbmZyZWV6ZShnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTtcblxuY29uc3QgZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcz0ob3B0aW9uTmFtZSxlbGVtZW50KT0+XG5hcnJheUluY2x1ZGVzKGdldEVudmlyb25tZW50T3B0aW9uc0xpc3Qob3B0aW9uTmFtZSksZWxlbWVudCk7XG5cbmNvbnN0IGdldENhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcz0oKT0+e1xucmV0dXJuIGZyZWV6ZShbLi4uY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzXSk7XG4gfTtcbmZyZWV6ZShnZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXMpO1xuXG5yZXR1cm4gZnJlZXplKHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMsXG5nZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXN9KTtcblxuIH07JGjNj19vbmNlLm1ha2VFbnZpcm9ubWVudENhcHRvcihtYWtlRW52aXJvbm1lbnRDYXB0b3IpO1xuZnJlZXplKG1ha2VFbnZpcm9ubWVudENhcHRvcik7XG5cbi8qKlxuICogRm9yIHRoZSBzaW1wbGUgY2FzZSwgd2hlcmUgdGhlIGdsb2JhbCBpbiBxdWVzdGlvbiBpcyBgZ2xvYmFsVGhpc2AgYW5kIG5vXG4gKiByZXBvcnRpbmcgb2Ygb3B0aW9uIG5hbWVzIGlzIGRlc2lyZWQuXG4gKi9cbmNvbnN0ICAgICAgIHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXN9PVxubWFrZUVudmlyb25tZW50Q2FwdG9yKGdsb2JhbFRoaXMsdHJ1ZSk7JGjNj19vbmNlLmdldEVudmlyb25tZW50T3B0aW9uKGdldEVudmlyb25tZW50T3B0aW9uKTskaM2PX29uY2UuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdChnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTskaM2PX29uY2UuZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyhlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbnZpcm9ubWVudENhcHRvciI6WyJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwiZ2V0RW52aXJvbm1lbnRPcHRpb24iOlsiZ2V0RW52aXJvbm1lbnRPcHRpb24iXSwiZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCI6WyJnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0Il0sImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiOlsiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADnjB5W6QwAAOkMAAAcAAAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiRmFpbCIsIlgiLCJhbm5vdGF0ZUVycm9yIiwiYXNzZXJ0IiwiYiIsImJhcmUiLCJtYWtlRXJyb3IiLCJub3RlIiwicSIsInF1b3RlIiwicmVkYWN0ZWQiLCJ0aHJvd1JlZGFjdGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogVGhpcyBtb2R1bGUgYXNzdW1lcyB0aGUgZXhpc3RlbmNlIG9mIGEgbm9uLXN0YW5kYXJkIGBhc3NlcnRgIGhvc3Qgb2JqZWN0LiovXG4vKiBTRVMgdmVyc2lvbiAwLjExLjAgaW50cm9kdWNlcyB0aGlzIGdsb2JhbCBvYmplY3QgYW5kIGVudGFuZ2xlcyBpdCovXG4vKiB3aXRoIHRoZSBgY29uc29sZWAgaG9zdCBvYmplY3QgaW4gc2NvcGUgd2hlbiBpdCBpbml0aWFsaXplcywqL1xuLyogYWxsb3dpbmcgZXJyb3JzLCBwYXJ0aWN1bGFybHkgYXNzZXJ0aW9uIGVycm9ycywgdG8gaGlkZSB0aGVpciBcImRldGFpbHNcIiovXG4vKiBmcm9tIGNhbGxlcnMgdGhhdCBtaWdodCBjYXRjaCB0aG9zZSBlcnJvcnMsIHRoZW4gcmV2ZWFsIHRoZW0gdG8gdGhlKi9cbi8qIHVuZGVybHlpbmcgY29uc29sZS4qL1xuLyogVG8gdGhlIGV4dGVudCB0aGF0IHRoaXMgYGNvbnNvbGVgIGlzIGNvbnNpZGVyZWQgYSByZXNvdXJjZSwqL1xuLyogdGhpcyBtb2R1bGUgbXVzdCBiZSBjb25zaWRlcmVkIGEgcmVzb3VyY2UgbW9kdWxlLiovXG5cbi8qIFRoZSBhc3NlcnRpb25zIHJlLWV4cG9ydGVkIGhlcmUgYXJlIGRlZmluZWQgaW4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL2Fzc2VydC5qcyovXG5cbmNvbnN0IGdsb2JhbEFzc2VydD1nbG9iYWxUaGlzLmFzc2VydDtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAZW5kby9lcnJvcnMsIG1pc3NpbmcgZ2xvYmFsVGhpcy5hc3NlcnQsIGltcG9ydCAnc2VzJyBiZWZvcmUgJ0BlbmRvL2Vycm9ycydgKTtcblxuIH1cblxuY29uc3QgbWlzc2luZz0vKiogQHR5cGUge2NvbnN0fSAqL1tcbid0eXBlb2YnLFxuJ2Vycm9yJyxcbidmYWlsJyxcbidlcXVhbCcsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyB0aGF0Ki9cbi8qIHByZWRhdGVzIGFkZGl0aW9uIG9mIHRoZSAnYmFyZScgbWV0aG9kLCBzbyB3ZSBtdXN0IHRvbGVyYXRlIGl0cyBhYnNlbmNlIGFuZCBmYWxsKi9cbi8qIGJhY2sgdG8gcXVvdGUgYmVoYXZpb3IgaW4gdGhhdCBlbnZpcm9ubWVudCAoc2VlIGJlbG93KS4qL1xuLyogJ2JhcmUnLCovXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBlbmRvL2Vycm9ycywgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCBtZXRob2RzICR7bWlzc2luZy5qb2luKFxuJywgJylcbiB9YCk7XG5cbiB9XG5cbi8qIFRoZSBnbG9iYWwgYXNzZXJ0IG1peGVkIGFzc2VydGlvbnMgYW5kIHV0aWxpdHkgZnVuY3Rpb25zLiovXG4vKiBUaGlzIG1vZHVsZSBzcGxpdHMgdGhlbSBhcGFydCovXG4vKiBhbmQgYWxzbyB1cGRhdGVzIHRoZSBuYW1lcyBvZiB0aGUgdXRpbGl0eSBmdW5jdGlvbnMuKi9cbmNvbnN0e1xuYmFyZSxcbmRldGFpbHM6cmVkYWN0ZWQsXG5lcnJvcjptYWtlRXJyb3IsXG5GYWlsOnRocm93UmVkYWN0ZWQsXG5tYWtlQXNzZXJ0Ol9vbWl0dGVkTWFrZUFzc2VydCxcbm5vdGUsXG5xdW90ZSxcbi4uLmFzc2VydGlvbnN9PVxuZ2xvYmFsQXNzZXJ0O1xuLyoqIEB0eXBlIHtJTVBPUlQoXCJzZXNcIikuQXNzZXJ0aW9uRnVuY3Rpb25zIH0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgbWlzc2luZyBwcm9wZXJ0aWVzIGFzc2lnbmVkIG5leHQqLyRozY9fb25jZS5yZWRhY3RlZChyZWRhY3RlZCk7JGjNj19vbmNlLm1ha2VFcnJvcihtYWtlRXJyb3IpOyRozY9fb25jZS50aHJvd1JlZGFjdGVkKHRocm93UmVkYWN0ZWQpOyRozY9fb25jZS5ub3RlKG5vdGUpOyRozY9fb25jZS5xdW90ZShxdW90ZSk7XG5jb25zdCBhc3NlcnQ9KHZhbHVlLG9wdERldGFpbHMsZXJyQ29udHJ1Y3RvcixvcHRpb25zKT0+XG5nbG9iYWxBc3NlcnQodmFsdWUsb3B0RGV0YWlscyxlcnJDb250cnVjdG9yLG9wdGlvbnMpOyRozY9fb25jZS5hc3NlcnQoYXNzZXJ0KTtcbk9iamVjdC5hc3NpZ24oYXNzZXJ0LGFzc2VydGlvbnMpO1xuXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyovXG4vKiB0aGF0IHByZWRhdGVzIHRoZSBhZGRpdGlvbiBvZiB0aGUgJ2JhcmUnIG1ldGhvZCwgc28gd2UgbXVzdCBmYWxsIGJhY2sgdG8qL1xuLyogcXVvdGUgYmVoYXZpb3IgZm9yIHRoYXQgZW52aXJvbm1lbnQuKi9cbmNvbnN0IGJhcmVPclF1b3RlPWJhcmV8fHF1b3RlO1xuXG4vKiBYWFggbW9kdWxlIGV4cG9ydHMgZmFpbCBpZiB0aGVzZSBhcmVuJ3QgaW4gc2NvcGUqL1xuLyoqIEBpbXBvcnQge0Fzc2VydE1ha2VFcnJvck9wdGlvbnMsIERldGFpbHMsIEdlbmVyaWNFcnJvckNvbnN0cnVjdG9yfSBmcm9tICdzZXMnICovJGjNj19vbmNlLmJhcmVPclF1b3RlKGJhcmVPclF1b3RlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlZGFjdGVkIjpbInJlZGFjdGVkIl0sIlgiOlsicmVkYWN0ZWQiXSwibWFrZUVycm9yIjpbIm1ha2VFcnJvciJdLCJ0aHJvd1JlZGFjdGVkIjpbInRocm93UmVkYWN0ZWQiXSwiRmFpbCI6WyJ0aHJvd1JlZGFjdGVkIl0sIm5vdGUiOlsibm90ZSJdLCJhbm5vdGF0ZUVycm9yIjpbIm5vdGUiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJhc3NlcnQiOlsiYXNzZXJ0Il0sImJhcmUiOlsiYmFyZU9yUXVvdGUiXSwiYiI6WyJiYXJlT3JRdW90ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL0UuanN7ImltcG9ydHMiOlsiLi90cmFjay10dXJucy5qcyIsIi4vbWVzc2FnZS1icmVha3BvaW50cy5qcyJdLCJleHBvcnRzIjpbImRlZmF1bHQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgdHJhY2tUdXJucyxtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXI7JGjNj19pbXBvcnRzKFtbXCIuL3RyYWNrLXR1cm5zLmpzXCIsIFtbXCJ0cmFja1R1cm5zXCIsIFskaM2PX2EgPT4gKHRyYWNrVHVybnMgPSAkaM2PX2EpXV1dXSxbXCIuL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW1tcIm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlclwiLCBbJGjNj19hID0+IChtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWwsZXJyb3I6bWFrZUVycm9yfT1hc3NlcnQ7XG5jb25zdHthc3NpZ24sZnJlZXplfT1PYmplY3Q7XG5cbi8qKlxuICogQGltcG9ydCB7IEhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3IgfSBmcm9tICcuL3R5cGVzLmpzJztcbiAqL1xuXG5jb25zdCBvblNlbmQ9bWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyKCdFTkRPX1NFTkRfQlJFQUtQT0lOVFMnKTtcblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qIEUgUHJveHkgaGFuZGxlcnMgcHJldGVuZCB0aGF0IGFueSBwcm9wZXJ0eSBleGlzdHMgb24gdGhlIHRhcmdldCBhbmQgcmV0dXJucyovXG4vKiBhIGZ1bmN0aW9uIGZvciB0aGVpciB2YWx1ZS4gV2hpbGUgdGhpcyBmdW5jdGlvbiBpcyBcImJvdW5kXCIgYnkgY29udGV4dCwgaXQgaXMqL1xuLyogbWVhbnQgdG8gYmUgY2FsbGVkIGFzIGEgbWV0aG9kLiBGb3IgdGhhdCByZWFzb24sIHRoZSByZXR1cm5lZCBmdW5jdGlvbiovXG4vKiBpbmNsdWRlcyBhIGNoZWNrIHRoYXQgdGhlIGB0aGlzYCBhcmd1bWVudCBjb3JyZXNwb25kcyB0byB0aGUgaW5pdGlhbCovXG4vKiByZWNlaXZlciB3aGVuIHRoZSBmdW5jdGlvbiB3YXMgcmV0cmlldmVkLiovXG4vKiBFIFByb3h5IGhhbmRsZXJzIGFsc28gZm9yd2FyZCBkaXJlY3QgY2FsbHMgdG8gdGhlIHRhcmdldCBpbiBjYXNlIHRoZSByZW1vdGUqL1xuLyogaXMgYSBmdW5jdGlvbiBpbnN0ZWFkIG9mIGFuIG9iamVjdC4gTm8gc3VjaCByZWNlaXZlciBjaGVja3MgYXJlIG5lY2Vzc2FyeSBpbiovXG4vKiB0aGF0IGNhc2UuKi9cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHthbnl9IHJlY2lwaWVudCBBbnkgdmFsdWUgcGFzc2VkIHRvIEUoeClcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXI8dW5rbm93bj59IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFUHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IFByb21pc2U8dW5rbm93bj59ICovXG5bcHJvcGVydHlLZXldKC4uLmFyZ3Mpe1xuaWYodGhpcyE9PXJlY2VpdmVyKXtcbi8qIFJlamVjdCB0aGUgYXN5bmMgZnVuY3Rpb24gY2FsbCovXG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVqZWN0KFxubWFrZUVycm9yKFxuWCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3EocHJvcGVydHlLZXkpfVwiIG1ldGhvZCBvZiBFKCR7cShcbnJlY2lwaWVudClcbiB9KWApKTtcblxuXG4gfVxuXG5pZihvblNlbmQmJm9uU2VuZC5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxwcm9wZXJ0eUtleSkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBtZXRob2QtY2FsbCovXG4vKiBtZXNzYWdlLCovXG4vKiBzbyB0aGF0IHlvdSBjYW4gd2FsayBiYWNrIG9uIHRoZSBzdGFjayB0byBzZWUgaG93IHdlIGNhbWUgdG8qL1xuLyogbWFrZSB0aGlzIGV2ZW50dWFsLXNlbmQqL1xuIH1cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZChyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucHJvcGVydHlLZXldKTtcblxuIH0sXG5hcHBseTooX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSk9PntcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBmdW5jdGlvbi1jYWxsIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ0FycmF5KTtcbiB9LFxuaGFzOihfdGFyZ2V0LF9wKT0+e1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUuc2VuZE9ubHkoeClcbiAqIEl0IGlzIGEgdmFyaWFudCBvbiB0aGUgRSh4KSBQcm94eSBoYW5kbGVyLlxuICpcbiAqIEBwYXJhbSB7YW55fSByZWNpcGllbnQgQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge0hhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7UHJveHlIYW5kbGVyPHVua25vd24+fSB0aGUgUHJveHkgaGFuZGxlclxuICovXG5jb25zdCBtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IHVuZGVmaW5lZH0gKi9cbltwcm9wZXJ0eUtleV0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShcbnByb3BlcnR5S2V5KVxuIH1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EocmVjaXBpZW50KX0pYDtcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHByb3BlcnR5S2V5KSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIG1ldGhvZC1jYWxsKi9cbi8qIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxuSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2RTZW5kT25seShyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDMxOSovfVtcbnByb3BlcnR5S2V5XSk7XG5cbiB9LFxuYXBwbHk6KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKT0+e1xuaWYob25TZW5kJiZvblNlbmQuc2hvdWxkQnJlYWtwb2ludChyZWNpcGllbnQsdW5kZWZpbmVkKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIGZ1bmN0aW9uLWNhbGwgbWVzc2FnZSwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHdhbGsgYmFjayBvbiB0aGUgc3RhY2sgdG8gc2VlIGhvdyB3ZSBjYW1lIHRvKi9cbi8qIG1ha2UgdGhpcyBldmVudHVhbC1zZW5kKi9cbiB9XG5IYW5kbGVkUHJvbWlzZS5hcHBseUZ1bmN0aW9uU2VuZE9ubHkocmVjaXBpZW50LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXM6KF90YXJnZXQsX3ApPT57XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLmdldCh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHthbnl9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLmdldCh4KVxuICogQHBhcmFtIHtIYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcjx1bmtub3duPn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuY29uc3QgbWFrZUVHZXRQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzOihfdGFyZ2V0LF9wcm9wKT0+dHJ1ZSxcbmdldDooX3RhcmdldCxwcm9wKT0+SGFuZGxlZFByb21pc2UuZ2V0KHgscHJvcCl9KTtcblxuXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBmdW5jVGFyZ2V0PWZyZWV6ZSgoKT0+eyB9KTtcblxuLyoqXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBvYmpUYXJnZXQ9ZnJlZXplKHtfX3Byb3RvX186bnVsbH0pO1xuXG4vKipcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqL1xuY29uc3QgbWFrZUU9KEhhbmRsZWRQcm9taXNlKT0+e1xucmV0dXJuIGhhcmRlbihcbmFzc2lnbihcbi8qKlxuICogRSh4KSByZXR1cm5zIGEgcHJveHkgb24gd2hpY2ggeW91IGNhbiBjYWxsIGFyYml0cmFyeSBtZXRob2RzLiBFYWNoIG9mIHRoZXNlXG4gKiBtZXRob2QgY2FsbHMgcmV0dXJucyBhIHByb21pc2UuIFRoZSBtZXRob2Qgd2lsbCBiZSBpbnZva2VkIG9uIHdoYXRldmVyXG4gKiAneCcgZGVzaWduYXRlcyAob3IgcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgbWV0aG9kL2Z1bmN0aW9uIGNhbGxcbiAqIEByZXR1cm5zIHtFQ2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqL1xuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG4oeCk9Pm5ldyBQcm94eShmdW5jVGFyZ2V0LG1ha2VFUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcbntcbi8qKlxuICogRS5nZXQoeCkgcmV0dXJucyBhIHByb3h5IG9uIHdoaWNoIHlvdSBjYW4gZ2V0IGFyYml0cmFyeSBwcm9wZXJ0aWVzLlxuICogRWFjaCBvZiB0aGVzZSBwcm9wZXJ0aWVzIHJldHVybnMgYSBwcm9taXNlIGZvciB0aGUgcHJvcGVydHkuICBUaGUgcHJvbWlzZVxuICogdmFsdWUgd2lsbCBiZSB0aGUgcHJvcGVydHkgZmV0Y2hlZCBmcm9tIHdoYXRldmVyICd4JyBkZXNpZ25hdGVzIChvclxuICogcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgcHJvcGVydHkgZ2V0XG4gKiBAcmV0dXJucyB7RUdldHRlcnM8TG9jYWxSZWNvcmQ8VD4+fSBwcm9wZXJ0eSBnZXQgcHJveHlcbiAqIEByZWFkb25seVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCB0eXBlZGVmKi9cbmdldDooeCk9Pm5ldyBQcm94eShvYmpUYXJnZXQsbWFrZUVHZXRQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSkpLFxuXG4vKipcbiAqIEUucmVzb2x2ZSh4KSBjb252ZXJ0cyB4IHRvIGEgaGFuZGxlZCBwcm9taXNlLiBJdCBpc1xuICogc2hvcnRoYW5kIGZvciBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gaGFuZGxlZCBwcm9taXNlIGZvciB4XG4gKiBAcmVhZG9ubHlcbiAqL1xucmVzb2x2ZTpIYW5kbGVkUHJvbWlzZS5yZXNvbHZlLFxuXG4vKipcbiAqIEUuc2VuZE9ubHkgcmV0dXJucyBhIHByb3h5IHNpbWlsYXIgdG8gRSwgYnV0IGZvciB3aGljaCB0aGUgcmVzdWx0c1xuICogYXJlIGlnbm9yZWQgKHVuZGVmaW5lZCBpcyByZXR1cm5lZCkuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB0YXJnZXQgZm9yIG1ldGhvZC9mdW5jdGlvbiBjYWxsXG4gKiBAcmV0dXJucyB7RVNlbmRPbmx5Q2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqIEByZWFkb25seVxuICovXG5zZW5kT25seTooeCk9PlxuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG5uZXcgUHJveHkoZnVuY1RhcmdldCxtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcblxuLyoqXG4gKiBFLndoZW4oeCwgcmVzLCByZWopIGlzIGVxdWl2YWxlbnQgdG9cbiAqIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihyZXMsIHJlailcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtVID0gVF1cbiAqIEBwYXJhbSB7VHxQcm9taXNlTGlrZTxUPn0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gRVJlZjxVPn0gW29uZnVsZmlsbGVkXVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IEVSZWY8VT59IFtvbnJlamVjdGVkXVxuICogQHJldHVybnMge1Byb21pc2U8VT59XG4gKiBAcmVhZG9ubHlcbiAqL1xud2hlbjooeCxvbmZ1bGZpbGxlZCxvbnJlamVjdGVkKT0+XG5IYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4oXG4uLi50cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSkpfSkpO1xuXG5cblxuXG4gfTtcblxuY29uc3R7ZGVmYXVsdDokY82PX2RlZmF1bHR9PXtkZWZhdWx0Om1ha2VFfTtcblxuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPG1ha2VFPn0gRVByb3h5ICovXG5cbi8qKlxuICogRGVjbGFyZSBhbiBvYmplY3QgdGhhdCBpcyBwb3RlbnRpYWxseSBhIGZhciByZWZlcmVuY2Ugb2YgdHlwZSBQcmltYXJ5IHdob3NlXG4gKiBhdXhpbGxpYXJ5IGRhdGEgaGFzIHR5cGUgTG9jYWwuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yIGNvbnN1bWVycyBvZlxuICogRmFyIG9iamVjdHMgaW4gYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHRoZSBvbmx5IGNyZWF0b3JzIG9mIEZhciBvYmplY3RzXG4gKiBhcmUgZGlzdHJpYnV0ZWQgb2JqZWN0IGNyZWF0b3IgY29tcG9uZW50cyBsaWtlIHRoZSBgRmFyYCBvciBgUmVtb3RhYmxlYFxuICogZnVuY3Rpb25zLlxuICpcbiAqIEB0ZW1wbGF0ZSBQcmltYXJ5IFRoZSB0eXBlIG9mIHRoZSBwcmltYXJ5IHJlZmVyZW5jZS5cbiAqIEB0ZW1wbGF0ZSBbTG9jYWw9RGF0YU9ubHk8UHJpbWFyeT5dIFRoZSBsb2NhbCBwcm9wZXJ0aWVzIG9mIHRoZSBvYmplY3QuXG4gKiBAdHlwZWRlZiB7RVJlZjxMb2NhbCAmIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPExvY2FsLCBQcmltYXJ5Pj59IEZhclJlZlxuICovXG5cbi8qKlxuICogYERhdGFPbmx5PFQ+YCBtZWFucyB0byByZXR1cm4gYSByZWNvcmQgdHlwZSBgVDJgIGNvbnNpc3Rpbmcgb25seSBvZlxuICogcHJvcGVydGllcyB0aGF0IGFyZSAqbm90KiBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgdG8gYmUgZmlsdGVyZWQuXG4gKiBAdHlwZWRlZiB7T21pdDxULCBGaWx0ZXJlZEtleXM8VCwgSU1QT1JUKCcuL3R5cGVzLmpzJykuQ2FsbGFibGU+Pn0gRGF0YU9ubHlcbiAqL1xuXG4vKipcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMzEzOTR9XG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1Byb21pc2VMaWtlPFQ+IHwgVH0gRVJlZlxuICogRGVjbGFyZSB0aGF0IGBUYCBtYXkgb3IgbWF5IG5vdCBiZSBhIFByb21pc2UuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yXG4gKiBjb25zdW1lcnMgb2YgYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHJldHVybiB2YWx1ZXMgc2hvdWxkIHNwZWNpZmljYWxseSBiZVxuICogYFByb21pc2U8VD5gIG9yIGBUYCBpdHNlbGYuXG4gKi9cblxuLyoqXG4gKiBUaGUgYXdhaXRlZCByZXR1cm4gdHlwZSBvZiBhIGZ1bmN0aW9uLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgKC4uLmFyZ3M6IGFueVtdKSA9PiBpbmZlciBSID8gQXdhaXRlZDxSPiA6IG5ldmVyfSBFUmV0dXJuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBSZXR1cm5UeXBlPFQ+IGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT4gICAgICAgICAgICAgICAgICAgICAgIC8vIGlmIGZ1bmN0aW9uIHJldHVybnMgYSBwcm9taXNlXG4gKiAgICAgPyBUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIHRoZSBmdW5jdGlvblxuICogICAgIDogKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8RVJldHVybjxUPj4gIC8vIG1ha2UgaXQgcmV0dXJuIGEgcHJvbWlzZVxuICogKX0gRUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRUNhbGxhYmxlPFRbUF0+XG4gKiAgICAgOiBuZXZlcjtcbiAqIH19IEVNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPlxuICogICAgID8gVFtQXVxuICogICAgIDogUHJvbWlzZTxBd2FpdGVkPFRbUF0+PjtcbiAqIH19IEVHZXR0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8dm9pZD59IEVTZW5kT25seUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VFtQXT5cbiAqICAgICA6IG5ldmVyO1xuICogfX0gRVNlbmRPbmx5TWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VD4gJiBFU2VuZE9ubHlNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogICAgIDogRVNlbmRPbmx5TWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICl9IEVTZW5kT25seUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyBFQ2FsbGFibGU8VD4gJiBFTWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICAgICA6IEVNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogKX0gRUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBSZXR1cm4gYSB1bmlvbiBvZiBwcm9wZXJ0eSBuYW1lcy9zeW1ib2xzL251bWJlcnMgUCBmb3Igd2hpY2ggdGhlIHJlY29yZCBlbGVtZW50IFRbUF0ncyB0eXBlIGV4dGVuZHMgVS5cbiAqXG4gKiBHaXZlbiBjb25zdCB4ID0geyBhOiAxMjMsIGI6ICdoZWxsbycsIGM6IDQyLCA0OTogKCkgPT4ge30sIDUzOiA2NyB9LFxuICpcbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgbnVtYmVyPiBpcyB0aGUgdHlwZSAnYScgfCAnYycgfCA1My5cbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgc3RyaW5nPiBpcyB0aGUgdHlwZSAnYicuXG4gKiBGaWx0ZXJlZEtleXM8dHlwZW9mIHgsIDQyIHwgNjc+IGlzIHRoZSB0eXBlICdjJyB8IDUzLlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBib29sZWFuPiBpcyB0aGUgdHlwZSBuZXZlci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFVcbiAqIEB0eXBlZGVmIHt7IFtQIGluIGtleW9mIFRdOiBUW1BdIGV4dGVuZHMgVSA/IFAgOiBuZXZlcjsgfVtrZXlvZiBUXX0gRmlsdGVyZWRLZXlzXG4gKi9cblxuLyoqXG4gKiBgUGlja0NhbGxhYmxlPFQ+YCBtZWFucyB0byByZXR1cm4gYSBzaW5nbGUgcm9vdCBjYWxsYWJsZSBvciBhIHJlY29yZCB0eXBlXG4gKiBjb25zaXN0aW5nIG9ubHkgb2YgcHJvcGVydGllcyB0aGF0IGFyZSBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFJldHVyblR5cGU8VD4gICAgICAgICAgICAgICAgICAgICAvLyBhIHJvb3QgY2FsbGFibGUsIG5vIG1ldGhvZHNcbiAqICAgICA6IFBpY2s8VCwgRmlsdGVyZWRLZXlzPFQsIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPj4gICAgICAgICAgLy8gYW55IGNhbGxhYmxlIG1ldGhvZHNcbiAqICl9IFBpY2tDYWxsYWJsZVxuICovXG5cbi8qKlxuICogYFJlbW90ZUZ1bmN0aW9uczxUPmAgbWVhbnMgdG8gcmV0dXJuIHRoZSBmdW5jdGlvbnMgYW5kIHByb3BlcnRpZXMgdGhhdCBhcmUgcmVtb3RlbHkgY2FsbGFibGUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPiAgICAgLy8gaWYgYSBnaXZlbiBUIGlzIHNvbWUgcmVtb3RlIGludGVyZmFjZSBSXG4gKiAgICAgPyBQaWNrQ2FsbGFibGU8Uj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gdGhlIGNhbGxhYmxlIHByb3BlcnRpZXMgb2YgUlxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+IC8vIG90aGVyd2lzZSwgaWYgdGhlIGZpbmFsIHJlc29sdXRpb24gb2YgVCBpcyBzb21lIHJlbW90ZSBpbnRlcmZhY2UgUlxuICogICAgID8gUGlja0NhbGxhYmxlPFI+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIHRoZW4gcmV0dXJuIHRoZSBjYWxsYWJsZSBwcm9wZXJ0aWVzIG9mIFJcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UsIGlmIFQgaXMgYSBwcm9taXNlXG4gKiAgICAgPyBBd2FpdGVkPFQ+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gcmVzb2x2ZWQgdmFsdWUgVFxuICogICAgIDogVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG90aGVyd2lzZSwgcmV0dXJuIFRcbiAqICl9IFJlbW90ZUZ1bmN0aW9uc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPlxuICogICAgID8gTFxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+XG4gKiAgICAgPyBMXG4gKiAgICAgOiBUIGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT5cbiAqICAgICA/IEF3YWl0ZWQ8VD5cbiAqICAgICA6IFRcbiAqICl9IExvY2FsUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1IgPSB1bmtub3duXVxuICogQHR5cGVkZWYge3tcbiAqICAgcHJvbWlzZTogUHJvbWlzZTxSPjtcbiAqICAgc2V0dGxlcjogSU1QT1JUKCcuL3R5cGVzLmpzJykuU2V0dGxlcjxSPjtcbiAqIH19IEVQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBEZWNsYXJlIGEgbmVhciBvYmplY3QgdGhhdCBtdXN0IG9ubHkgYmUgaW52b2tlZCB3aXRoIEUsIGV2ZW4gbG9jYWxseS4gIEl0XG4gKiBzdXBwb3J0cyB0aGUgYFRgIGludGVyZmFjZSBidXQgYWRkaXRpb25hbGx5IHBlcm1pdHMgYFRgJ3MgbWV0aG9kcyB0byByZXR1cm5cbiAqIGBQcm9taXNlTGlrZWBzIGV2ZW4gaWYgYFRgIGRlY2xhcmVzIHRoZW0gYXMgb25seSBzeW5jaHJvbm91cy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VD4+Pj5cbiAqICAgICA6IFQgZXh0ZW5kcyBSZWNvcmQ8UHJvcGVydHlLZXksIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPlxuICogICAgID8ge1xuICogICAgICAgICBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgICAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUW0tdPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VFtLXT4+Pj5cbiAqICAgICAgICAgICA6IFRbS107XG4gKiAgICAgICB9XG4gKiAgICAgOiBUXG4gKiApfSBFT25seVxuICovJGjNj19vbmNlLmRlZmF1bHQoJGPNj19kZWZhdWx0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2V4cG9ydHMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG2wnmyYEQAAmBEAACcAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanN7ImltcG9ydHMiOlsiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOlsiZ2V0TWV0aG9kTmFtZXMiLCJsb2NhbEFwcGx5RnVuY3Rpb24iLCJsb2NhbEFwcGx5TWV0aG9kIiwibG9jYWxHZXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyOyRozY9faW1wb3J0cyhbW1wiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzXCIsIFtbXCJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcIiwgWyRozY9fYSA9PiAobWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyID0gJGjNj19hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzLGdldFByb3RvdHlwZU9mLGZyZWV6ZX09T2JqZWN0O1xuY29uc3R7YXBwbHksb3duS2V5c309UmVmbGVjdDtcblxuY29uc3QgbnR5cGVvZj0oc3BlY2ltZW4pPT5zcGVjaW1lbj09PW51bGw/J251bGwnOnR5cGVvZiBzcGVjaW1lbjtcblxuY29uc3Qgb25EZWxpdmVyeT1tYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIoJ0VORE9fREVMSVZFUllfQlJFQUtQT0lOVFMnKTtcblxuLyoqXG4gKiBUT0RPIENvbnNvbGlkYXRlIHdpdGggYGlzT2JqZWN0YCB0aGF0J3MgY3VycmVudGx5IGluIGBAZW5kby9tYXJzaGFsYFxuICpcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7XG5cbi8qKlxuICogUHJpb3JpdGl6ZSBzeW1ib2xzIGFzIGVhcmxpZXIgdGhhbiBzdHJpbmdzLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0gYVxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBiXG4gKiBAcmV0dXJucyB7LTEgfCAwIHwgMX1cbiAqL1xuY29uc3QgY29tcGFyZVN0cmluZ2lmaWVkPShhLGIpPT57XG5pZih0eXBlb2YgYT09PXR5cGVvZiBiKXtcbmNvbnN0IGxlZnQ9U3RyaW5nKGEpO1xuY29uc3QgcmlnaHQ9U3RyaW5nKGIpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLW5lc3RlZC10ZXJuYXJ5Ki9cbnJldHVybiBsZWZ0PHJpZ2h0Py0xOmxlZnQ+cmlnaHQ/MTowO1xuIH1cbmlmKHR5cGVvZiBhPT09J3N5bWJvbCcpe1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N0cmluZycpO1xucmV0dXJuLTE7XG4gfVxuYXNzZXJ0KHR5cGVvZiBhPT09J3N0cmluZycpO1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N5bWJvbCcpO1xucmV0dXJuIDE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGRlc2NzKSl7XG4vKiBJbiBjYXNlIGEgbWV0aG9kIGlzIG92ZXJyaWRkZW4gYnkgYSBub24tbWV0aG9kLCovXG4vKiB0ZXN0IGB2YWxbbmFtZV1gIHJhdGhlciB0aGFuIGBsYXllcltuYW1lXWAqL1xuaWYodHlwZW9mIHZhbFtuYW1lXT09PSdmdW5jdGlvbicpe1xubmFtZXMuYWRkKG5hbWUpO1xuIH1cbiB9XG5pZighaXNPYmplY3QodmFsKSl7XG5icmVhaztcbiB9XG5sYXllcj1nZXRQcm90b3R5cGVPZihsYXllcik7XG4gfVxucmV0dXJuIGhhcmRlbihbLi4ubmFtZXNdLnNvcnQoY29tcGFyZVN0cmluZ2lmaWVkKSk7XG4gfTtcbi8qIFRoZSB0b3AgbGV2ZWwgb2YgdGhlIGV2ZW50dWFsIHNlbmQgbW9kdWxlcyBjYW4gYmUgZXZhbHVhdGVkIGJlZm9yZSovXG4vKiBzZXMgY3JlYXRlcyBgaGFyZGVuYCwgYW5kIHNvIGNhbm5vdCByZWx5IG9uIGBoYXJkZW5gIGF0IHRvcCBsZXZlbC4qLyRozY9fb25jZS5nZXRNZXRob2ROYW1lcyhnZXRNZXRob2ROYW1lcyk7XG5mcmVlemUoZ2V0TWV0aG9kTmFtZXMpO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseUZ1bmN0aW9uPShyZWNpcGllbnQsYXJncyk9PntcbnR5cGVvZiByZWNpcGllbnQ9PT0nZnVuY3Rpb24nfHxcbmFzc2VydC5mYWlsKFxuWCBgQ2Fubm90IGludm9rZSB0YXJnZXQgYXMgYSBmdW5jdGlvbjsgdHlwZW9mIHRhcmdldCBpcyAke3EoXG5udHlwZW9mKHJlY2lwaWVudCkpXG4gfWAsXG5UeXBlRXJyb3IpO1xuXG5pZihvbkRlbGl2ZXJ5JiZvbkRlbGl2ZXJ5LnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIFNURVAgSU5UTyBBUFBMWSovXG4vKiBTdG9wcGVkIGF0IGEgYnJlYWtwb2ludCBvbiB0aGlzIGRlbGl2ZXJ5IG9mIGFuIGV2ZW50dWFsIGZ1bmN0aW9uIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIGZ1bmN0aW9uIGNhbGwgYXMgaXQgaGFwcGVucy4gT3Igc3RlcCAqb3ZlciogdG8gc2VlIHdoYXQgaGFwcGVucyovXG4vKiBhZnRlciB0aGUgZnVuY3Rpb24gY2FsbCByZXR1cm5zLiovXG4gfVxuY29uc3QgcmVzdWx0PWFwcGx5KHJlY2lwaWVudCx1bmRlZmluZWQsYXJncyk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjNj19vbmNlLmxvY2FsQXBwbHlGdW5jdGlvbihsb2NhbEFwcGx5RnVuY3Rpb24pO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseU1ldGhvZD0ocmVjaXBpZW50LG1ldGhvZE5hbWUsYXJncyk9PntcbmlmKG1ldGhvZE5hbWU9PT11bmRlZmluZWR8fG1ldGhvZE5hbWU9PT1udWxsKXtcbi8qIEJhc2UgY2FzZTsgYm90dG9tIG91dCB0byBhcHBseSBmdW5jdGlvbnMuKi9cbnJldHVybiBsb2NhbEFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ3MpO1xuIH1cbmlmKHJlY2lwaWVudD09PXVuZGVmaW5lZHx8cmVjaXBpZW50PT09bnVsbCl7XG5hc3NlcnQuZmFpbChcblggYENhbm5vdCBkZWxpdmVyICR7cShtZXRob2ROYW1lKX0gdG8gdGFyZ2V0OyB0eXBlb2YgdGFyZ2V0IGlzICR7cShcbm50eXBlb2YocmVjaXBpZW50KSlcbiB9YCxcblR5cGVFcnJvcik7XG5cbiB9XG5jb25zdCBmbj1yZWNpcGllbnRbbWV0aG9kTmFtZV07XG5pZihmbj09PXVuZGVmaW5lZCl7XG5hc3NlcnQuZmFpbChcblggYHRhcmdldCBoYXMgbm8gbWV0aG9kICR7cShtZXRob2ROYW1lKX0sIGhhcyAke3EoXG5nZXRNZXRob2ROYW1lcyhyZWNpcGllbnQpKVxuIH1gLFxuVHlwZUVycm9yKTtcblxuIH1cbmNvbnN0IGZ0eXBlPW50eXBlb2YoZm4pO1xudHlwZW9mIGZuPT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBpbnZva2VkIG1ldGhvZCAke3EobWV0aG9kTmFtZSl9IGlzIG5vdCBhIGZ1bmN0aW9uOyBpdCBpcyBhICR7cShcbmZ0eXBlKVxuIH1gO1xuaWYob25EZWxpdmVyeSYmb25EZWxpdmVyeS5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxtZXRob2ROYW1lKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogU1RFUCBJTlRPIEFQUExZKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIHRoaXMgZGVsaXZlcnkgb2YgYW4gZXZlbnR1YWwgbWV0aG9kIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIG1ldGhvZCBjYWxsIGFzIGl0IGhhcHBlbnMuIE9yIHN0ZXAgKm92ZXIqIHRvIHNlZSB3aGF0IGhhcHBlbnMqL1xuLyogYWZ0ZXIgdGhlIG1ldGhvZCBjYWxsIHJldHVybnMuKi9cbiB9XG5jb25zdCByZXN1bHQ9YXBwbHkoZm4scmVjaXBpZW50LGFyZ3MpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRozY9fb25jZS5sb2NhbEFwcGx5TWV0aG9kKGxvY2FsQXBwbHlNZXRob2QpO1xuXG5jb25zdCAgICAgICAgbG9jYWxHZXQ9KHQsa2V5KT0+dFtrZXldOyRozY9fb25jZS5sb2NhbEdldChsb2NhbEdldCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJsb2NhbEFwcGx5RnVuY3Rpb24iOlsibG9jYWxBcHBseUZ1bmN0aW9uIl0sImxvY2FsQXBwbHlNZXRob2QiOlsibG9jYWxBcHBseU1ldGhvZCJdLCJsb2NhbEdldCI6WyJsb2NhbEdldCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABt8TAWoRYAAKEWAAA1AAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgZ2V0RW52aXJvbm1lbnRPcHRpb247JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuY29uc3R7aGFzT3duLGZyZWV6ZSxlbnRyaWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZyB8ICcqJ30gTWF0Y2hTdHJpbmdUYWdcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IHJlY2lwaWVudC4gT3RoZXJ3aXNlLCB0aGUgc3RyaW5nIGlzXG4gKiAgIG1hdGNoZWQgYWdhaW5zdCB0aGUgdmFsdWUgb2YgYSByZWNpcGllbnQncyBgQEB0b1N0cmluZ1RhZ2BcbiAqICAgYWZ0ZXIgc3RyaXBwaW5nIG91dCBhbnkgbGVhZGluZyBgJ0FsbGVnZWQ6ICdgIG9yIGAnRGVidWdOYW1lOiAnYFxuICogICBwcmVmaXguIEZvciBvYmplY3RzIGRlZmluZWQgd2l0aCBgRmFyYCB0aGlzIGlzIHRoZSBmaXJzdCBhcmd1bWVudCxcbiAqICAga25vd24gYXMgdGhlIGBmYXJOYW1lYC4gRm9yIGV4b3MsIHRoaXMgaXMgdGhlIHRhZy5cbiAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgJyonfSBNYXRjaE1ldGhvZE5hbWVcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IG1ldGhvZCBuYW1lLiBPdGhlcndpc2UsIHRoZSBzdHJpbmcgaXNcbiAqICAgbWF0Y2hlZCBhZ2FpbnN0IHRoZSBtZXRob2QgbmFtZS4gQ3VycmVudGx5LCB0aGlzIGlzIG9ubHkgYW4gZXhhY3QgbWF0Y2guXG4gKiAgIEhvd2V2ZXIsIGJld2FyZSB0aGF0IHdlIG1heSBpbnRyb2R1Y2UgYSBzdHJpbmcgc3ludGF4IGZvclxuICogICBzeW1ib2wgbWV0aG9kIG5hbWVzLlxuICovXG4vKipcbiAqIEB0eXBlZGVmIHtudW1iZXIgfCAnKid9IE1hdGNoQ291bnRkb3duXG4gKiAgIEEgc3RhciBgJyonYCB3aWxsIGFsd2F5cyBicmVha3BvaW50LiBPdGhlcndpc2UsIHRoZSBzdHJpbmdcbiAqICAgbXVzdCBiZSBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyLiBPbmNlIHRoYXQgaXMgemVybywgYWx3YXlzIGJyZWFrcG9pbnQuXG4gKiAgIE90aGVyd2lzZSBkZWNyZW1lbnQgYnkgb25lIGVhY2ggdGltZSBpdCBtYXRjaGVzIHVudGlsIGl0IHJlYWNoZXMgemVyby5cbiAqICAgSW4gb3RoZXIgd29yZHMsIHRoZSBjb3VudGRvd24gcmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mXG4gKiAgIGJyZWFrcG9pbnQgb2NjdXJyZW5jZXMgdG8gc2tpcCBiZWZvcmUgYWN0dWFsbHkgYnJlYWtwb2ludGluZy5cbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIGV4dGVybmFsIEpTT04gcmVwcmVzZW50YXRpb24sIGluIHdoaWNoXG4gKiAtIHRoZSBvdXRlciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBjbGFzcy1saWtlIHRhZyBvciAnKicsXG4gKiAtIHRoZSBpbm5lciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBtZXRob2QgbmFtZSBvciAnKicsXG4gKiAtIHRoZSB2YWx1ZSBpcyBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyIGNvdW50ZG93biBvciAnKicuXG4gKlxuICogQHR5cGVkZWYge1JlY29yZDxNYXRjaFN0cmluZ1RhZywgUmVjb3JkPE1hdGNoTWV0aG9kTmFtZSwgTWF0Y2hDb3VudGRvd24+Pn0gTWVzc2FnZUJyZWFrcG9pbnRzXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBpbnRlcm5hbCBKU09OIHJlcHJlc2VudGF0aW9uLCBpbiB3aGljaFxuICogLSB0aGUgb3V0ZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgbWV0aG9kIG5hbWUgb3IgJyonLFxuICogLSB0aGUgaW5uZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgY2xhc3MtbGlrZSB0YWcgb3IgJyonLFxuICogLSB0aGUgdmFsdWUgaXMgYSBub24tbmVnYXRpdmUgaW50ZWdlciBjb3VudGRvd24gb3IgJyonLlxuICpcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8TWF0Y2hNZXRob2ROYW1lLCBSZWNvcmQ8TWF0Y2hTdHJpbmdUYWcsIE1hdGNoQ291bnRkb3duPj59IEJyZWFrcG9pbnRUYWJsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gTWVzc2FnZUJyZWFrcG9pbnRzfSBnZXRCcmVha3BvaW50c1xuICogQHByb3BlcnR5IHsobmV3QnJlYWtwb2ludHM/OiBNZXNzYWdlQnJlYWtwb2ludHMpID0+IHZvaWR9IHNldEJyZWFrcG9pbnRzXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVjaXBpZW50OiBvYmplY3QsXG4gKiAgIG1ldGhvZE5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IHVuZGVmaW5lZFxuICogKSA9PiBib29sZWFufSBzaG91bGRCcmVha3BvaW50XG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7dmFsIGlzIFJlY29yZDxzdHJpbmcsIGFueT59XG4gKi9cbmNvbnN0IGlzSlNPTlJlY29yZD0odmFsKT0+XG50eXBlb2YgdmFsPT09J29iamVjdCcmJnZhbCE9PW51bGwmJiFBcnJheS5pc0FycmF5KHZhbCk7XG5cbi8qKlxuICogUmV0dXJuIGB0YWdgIGFmdGVyIHN0cmlwcGluZyBvZmYgYW55IGAnQWxsZWdlZDogJ2Agb3IgYCdEZWJ1Z05hbWU6ICdgXG4gKiBwcmVmaXggaWYgcHJlc2VudC5cbiAqIGBgYGpzXG4gKiBzaW1wbGlmeVRhZygnQWxsZWdlZDogbW9vbGEgaXNzdWVyJykgPT09ICdtb29sYSBpc3N1ZXInXG4gKiBgYGBcbiAqIElmIHRoZXJlIGFyZSBtdWx0aXBsZSBzdWNoIHByZWZpeGVzLCBvbmx5IHRoZSBvdXRlciBvbmUgaXMgcmVtb3ZlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBzaW1wbGlmeVRhZz0odGFnKT0+e1xuZm9yKGNvbnN0IHByZWZpeCBvZlsnQWxsZWdlZDogJywnRGVidWdOYW1lOiAnXSl7XG5pZih0YWcuc3RhcnRzV2l0aChwcmVmaXgpKXtcbnJldHVybiB0YWcuc2xpY2UocHJlZml4Lmxlbmd0aCk7XG4gfVxuIH1cbnJldHVybiB0YWc7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge01lc3NhZ2VCcmVha3BvaW50VGVzdGVyIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCAgICAgICAgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyPShvcHRpb25OYW1lKT0+e1xubGV0IGJyZWFrcG9pbnRzPUpTT04ucGFyc2UoZ2V0RW52aXJvbm1lbnRPcHRpb24ob3B0aW9uTmFtZSwnbnVsbCcpKTtcblxuaWYoYnJlYWtwb2ludHM9PT1udWxsKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbmxldCBicmVha3BvaW50c1RhYmxlO1xuXG5jb25zdCBnZXRCcmVha3BvaW50cz0oKT0+YnJlYWtwb2ludHM7XG5mcmVlemUoZ2V0QnJlYWtwb2ludHMpO1xuXG5jb25zdCBzZXRCcmVha3BvaW50cz0obmV3QnJlYWtwb2ludHM9YnJlYWtwb2ludHMpPT57XG5pc0pTT05SZWNvcmQobmV3QnJlYWtwb2ludHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uIHRvIGJlIGEgSlNPTiBicmVha3BvaW50cyByZWNvcmRgO1xuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbmNvbnN0IG5ld0JyZWFrcG9pbnRzVGFibGU9e19fcHJvdG9fXzpudWxsfTtcblxuZm9yKGNvbnN0W3RhZyxtZXRob2RCUHNdb2YgZW50cmllcyhuZXdCcmVha3BvaW50cykpe1xudGFnPT09c2ltcGxpZnlUYWcodGFnKXx8XG5GYWlsIGBKdXN0IHVzZSBzaW1wbGUgdGFnICR7cShzaW1wbGlmeVRhZyh0YWcpKX0gcmF0aGVyIHRoYW4gJHtxKHRhZyl9YDtcbmlzSlNPTlJlY29yZChtZXRob2RCUHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uJ3MgJHtxKFxudGFnKVxuIH0gdG8gYmUgYSBKU09OIG1ldGhvZHMgYnJlYWtwb2ludHMgcmVjb3JkYDtcbmZvcihjb25zdFttZXRob2ROYW1lLGNvdW50XW9mIGVudHJpZXMobWV0aG9kQlBzKSl7XG5jb3VudD09PScqJ3x8XG50eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmXG5OdW1iZXIuaXNTYWZlSW50ZWdlcihjb3VudCkmJlxuY291bnQ+PTB8fFxuRmFpbCBgRXhwZWN0ZWQgJHtxKG9wdGlvbk5hbWUpfSBvcHRpb24ncyAke3EodGFnKX0uJHtxKFxubWV0aG9kTmFtZSlcbiB9IHRvIGJlIFwiKlwiIG9yIGEgbm9uLW5lZ2F0aXZlIGludGVnZXJgO1xuXG5jb25zdCBjbGFzc0JQcz1oYXNPd24obmV3QnJlYWtwb2ludHNUYWJsZSxtZXRob2ROYW1lKT9cbm5ld0JyZWFrcG9pbnRzVGFibGVbbWV0aG9kTmFtZV06XG5uZXdCcmVha3BvaW50c1RhYmxlW21ldGhvZE5hbWVdPXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbl9fcHJvdG9fXzpudWxsfTtcblxuY2xhc3NCUHNbdGFnXT1jb3VudDtcbiB9XG4gfVxuYnJlYWtwb2ludHM9bmV3QnJlYWtwb2ludHM7XG5icmVha3BvaW50c1RhYmxlPW5ld0JyZWFrcG9pbnRzVGFibGU7XG4gfTtcbmZyZWV6ZShzZXRCcmVha3BvaW50cyk7XG5cbmNvbnN0IHNob3VsZEJyZWFrcG9pbnQ9KHJlY2lwaWVudCxtZXRob2ROYW1lKT0+e1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZHx8bWV0aG9kTmFtZT09PW51bGwpe1xuLyogVE9ETyBlbmFibGUgZnVuY3Rpb24gYnJlYWtwb2ludGluZyovXG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgY2xhc3NCUHM9YnJlYWtwb2ludHNUYWJsZVttZXRob2ROYW1lXXx8YnJlYWtwb2ludHNUYWJsZVsnKiddO1xuaWYoY2xhc3NCUHM9PT11bmRlZmluZWQpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmxldCB0YWc9c2ltcGxpZnlUYWcocmVjaXBpZW50W1N5bWJvbC50b1N0cmluZ1RhZ10pO1xubGV0IGNvdW50PWNsYXNzQlBzW3RhZ107XG5pZihjb3VudD09PXVuZGVmaW5lZCl7XG50YWc9JyonO1xuY291bnQ9Y2xhc3NCUHNbdGFnXTtcbmlmKGNvdW50PT09dW5kZWZpbmVkKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuaWYoY291bnQ9PT0nKicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoY291bnQ9PT0wKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydCh0eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmY291bnQ+PTEpO1xuY2xhc3NCUHNbdGFnXT1jb3VudC0xO1xucmV0dXJuIGZhbHNlO1xuIH07XG5mcmVlemUoc2hvdWxkQnJlYWtwb2ludCk7XG5cbmNvbnN0IGJyZWFrcG9pbnRUZXN0ZXI9ZnJlZXplKHtcbmdldEJyZWFrcG9pbnRzLFxuc2V0QnJlYWtwb2ludHMsXG5zaG91bGRCcmVha3BvaW50fSk7XG5cbmJyZWFrcG9pbnRUZXN0ZXIuc2V0QnJlYWtwb2ludHMoKTtcbnJldHVybiBicmVha3BvaW50VGVzdGVyO1xuIH07JGjNj19vbmNlLm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlcihtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIpO1xuZnJlZXplKG1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3Rlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiOlsibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABeEUwx5AwAAeQMAACkAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbm8tc2hpbS5qc3siaW1wb3J0cyI6WyIuL0UuanMiLCIuL2V4cG9ydHMuanMiXSwiZXhwb3J0cyI6WyJFIiwiSGFuZGxlZFByb21pc2UiXSwicmVleHBvcnRzIjpbIi4vZXhwb3J0cy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBtYWtlRTskaM2PX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbW1wiZGVmYXVsdFwiLCBbJGjNj19hID0+IChtYWtlRSA9ICRozY9fYSldXV1dLFtcIi4vZXhwb3J0cy5qc1wiLCBbXV1dKTsgICBcblxuLyogWFhYIG1vZHVsZSBleHBvcnRzIGZvciBIYW5kbGVkUHJvbWlzZSBmYWlsIGlmIHRoZXNlIGFyZW4ndCBpbiBzY29wZSovXG4vKiogQGltcG9ydCB7SGFuZGxlciwgSGFuZGxlZEV4ZWN1dG9yfSBmcm9tICcuL2hhbmRsZWQtcHJvbWlzZS5qcycgKi9cbi8qKiBAaW1wb3J0IHtFQ2FsbGFibGVPck1ldGhvZHMsIEVHZXR0ZXJzLCBFUmVmLCBFUmVtb3RlRnVuY3Rpb25zLCBFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kcywgTG9jYWxSZWNvcmQsIFJlbW90ZUZ1bmN0aW9uc30gZnJvbSAnLi9FLmpzJyAqL1xuXG5jb25zdCBocD1IYW5kbGVkUHJvbWlzZTskaM2PX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoaHApOyRozY9fb25jZS5FKEUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiSGFuZGxlZFByb21pc2UiOlsiaHAiXSwiRSI6WyJFIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB6458vtEAAA7RAAAC0AAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJ0cmFja1R1cm5zIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLGVudmlyb25tZW50T3B0aW9uc0xpc3RIYXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV0sW1wiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhc1wiLCBbJGjNj19hID0+IChlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIFdlIGFsc28gY2Fubm90IGN1cnJlbnRseSBpbXBvcnQgdGhlbSBiZWNhdXNlIGl0IHdvdWxkIGNyZWF0ZSBhIGN5Y2xpYyovXG4vKiBkZXBlbmRlbmN5LCB0aG91Z2ggdGhpcyBpcyBtb3JlIGVhc2lseSBmaXhlZC4qL1xuLyogaW1wb3J0IHsgYXNzZXJ0LCBYLCBGYWlsIH0gZnJvbSAnQGVuZG8vZXJyb3JzJzsqL1xuLyogU2VlIGFsc28gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85NTE1Ki9cblxuLyogV0FSTklORzogR2xvYmFsIE11dGFibGUgU3RhdGUhKi9cbi8qIFRoaXMgc3RhdGUgaXMgY29tbXVuaWNhdGVkIHRvIGBhc3NlcnRgIHRoYXQgbWFrZXMgaXQgYXZhaWxhYmxlIHRvIHRoZSovXG4vKiBjYXVzYWwgY29uc29sZSwgd2hpY2ggYWZmZWN0cyB0aGUgY29uc29sZSBsb2cgb3V0cHV0LiBOb3JtYWxseSB3ZSovXG4vKiByZWdhcmQgdGhlIGFiaWxpdHkgdG8gc2VlIGNvbnNvbGUgbG9nIG91dHB1dCBhcyBhIG1ldGEtbGV2ZWwgcHJpdmlsZWdlKi9cbi8qIGFuYWxvZ291cyB0byB0aGUgYWJpbGl0eSB0byBkZWJ1Zy4gQXNpZGUgZnJvbSB0aGF0LCB0aGlzIG1vZHVsZSBzaG91bGQqL1xuLyogbm90IGhhdmUgYW55IG9ic2VydmFibHkgbXV0YWJsZSBzdGF0ZS4qL1xuXG5sZXQgaGlkZGVuUHJpb3JFcnJvcjtcbmxldCBoaWRkZW5DdXJyZW50VHVybj0wO1xubGV0IGhpZGRlbkN1cnJlbnRFdmVudD0wO1xuXG4vKiBUdXJuIG9uIGlmIHlvdSBzZWVtIHRvIGJlIGxvc2luZyBlcnJvciBsb2dnaW5nIGF0IHRoZSB0b3Agb2YgdGhlIGV2ZW50IGxvb3AqL1xuY29uc3QgVkVSQk9TRT1lbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKCdERUJVRycsJ3RyYWNrLXR1cm5zJyk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBlbmFibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgRU5BQkxFRD1cbmdldEVudmlyb25tZW50T3B0aW9uKCdUUkFDS19UVVJOUycsJ2Rpc2FibGVkJyxbJ2VuYWJsZWQnXSk9PT0nZW5hYmxlZCc7XG5cbi8qIFdlIGhvaXN0IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIG91dCBvZiB0cmFja1R1cm5zKCkgdG8gZGlzY291cmFnZSB0aGUqL1xuLyogY2xvc3VyZXMgZnJvbSBob2xkaW5nIG9udG8gJ2FyZ3MnIG9yICdmdW5jJyBsb25nZXIgdGhhbiBuZWNlc3NhcnksKi9cbi8qIHdoaWNoIHdlJ3ZlIHNlZW4gY2F1c2UgSGFuZGxlZFByb21pc2UgYXJndW1lbnRzIHRvIGJlIHJldGFpbmVkIGZvciovXG4vKiBhIHN1cnByaXNpbmdseSBsb25nIHRpbWUuKi9cblxuY29uc3QgYWRkUmVqZWN0aW9uTm90ZT0oZGV0YWlsc05vdGUpPT4ocmVhc29uKT0+e1xuaWYocmVhc29uIGluc3RhbmNlb2YgRXJyb3Ipe1xuZ2xvYmFsVGhpcy5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9O1xuXG5jb25zdCB3cmFwRnVuY3Rpb249XG4oZnVuYyxzZW5kaW5nRXJyb3IsWCk9PlxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5nbG9iYWxUaGlzLmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goYWRkUmVqZWN0aW9uTm90ZShkZXRhaWxzTm90ZSkpO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9O1xuXG4vKipcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAdGVtcGxhdGUge1R1cm5TdGFydGVyRm5bXX0gVFxuICogQHBhcmFtIHtUfSBmdW5jc1xuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICB0cmFja1R1cm5zPShmdW5jcyk9PntcbmlmKCFFTkFCTEVEfHx0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WCxub3RlOmFubm90YXRlRXJyb3J9PWdsb2JhbFRoaXMuYXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9RXJyb3IoXG4gYEV2ZW50OiAke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuaWYoaGlkZGVuUHJpb3JFcnJvciE9PXVuZGVmaW5lZCl7XG5hbm5vdGF0ZUVycm9yKHNlbmRpbmdFcnJvcixYIGBDYXVzZWQgYnk6ICR7aGlkZGVuUHJpb3JFcnJvcn1gKTtcbiB9XG5cbnJldHVybiAoLyoqIEB0eXBlIHtUfSAqL1xuZnVuY3MubWFwKChmdW5jKT0+ZnVuYyYmd3JhcEZ1bmN0aW9uKGZ1bmMsc2VuZGluZ0Vycm9yLFgpKSk7XG5cbiB9O1xuXG4vKipcbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICpcbiAqIEB0eXBlZGVmIHsoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgdW5kZWZpbmVkfSBUdXJuU3RhcnRlckZuXG4gKi8kaM2PX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InRyYWNrVHVybnMiOlsidHJhY2tUdXJucyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA/8Oc6VgIAAFYCAAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvdXRpbHMuanN7ImltcG9ydHMiOlsiLi9zcmMvbG9jYWwuanMiLCIuL3NyYy9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOltudWxsLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvbG9jYWwuanNcIiwgW11dLFtcIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9sb2NhbC5qcyI6W1siZ2V0TWV0aG9kTmFtZXMiLCJnZXRNZXRob2ROYW1lcyJdXSwiLi9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyI6W1sibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIiwibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC4gWnwdAcAAHQHAAAdAAAAQGVuZG8vbWFyc2hhbC12MS42LjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9zcmMvbWFyc2hhbC5qcyIsIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIiwiLi9zcmMvbWFyc2hhbC1qdXN0aW4uanMiLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyIsIi4vc3JjL3JhbmtPcmRlci5qcyIsIi4vc3JjL3R5cGVzLmpzIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImFzc2VydFJhbmtTb3J0ZWQiLCJhc3NlcnRSYW5rU29ydGVkIiwibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIiwicGFyc2UiLCJwYXJzZSIsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW1tcIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtanVzdGluLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvcmFua09yZGVyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbXV1dKTsgICBcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyI6W1siUUNMQVNTIiwiUUNMQVNTIl1dLCIuL3NyYy9tYXJzaGFsLmpzIjpbWyJtYWtlTWFyc2hhbCIsIm1ha2VNYXJzaGFsIl1dLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6W1sic3RyaW5naWZ5Iiwic3RyaW5naWZ5Il0sWyJwYXJzZSIsInBhcnNlIl1dLCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6W1siZGVjb2RlVG9KdXN0aW4iLCJkZWNvZGVUb0p1c3RpbiJdXSwiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOltbIm1ha2VQYXNzYWJsZUtpdCIsIm1ha2VQYXNzYWJsZUtpdCJdLFsibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIl0sWyJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiXSxbImlzRW5jb2RlZFJlbW90YWJsZSIsImlzRW5jb2RlZFJlbW90YWJsZSJdLFsiemVyb1BhZCIsInplcm9QYWQiXSxbInJlY29yZE5hbWVzIiwicmVjb3JkTmFtZXMiXSxbInJlY29yZFZhbHVlcyIsInJlY29yZFZhbHVlcyJdXSwiLi9zcmMvcmFua09yZGVyLmpzIjpbWyJ0cml2aWFsQ29tcGFyYXRvciIsInRyaXZpYWxDb21wYXJhdG9yIl0sWyJhc3NlcnRSYW5rU29ydGVkIiwiYXNzZXJ0UmFua1NvcnRlZCJdLFsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayJdLFsiaXNSYW5rU29ydGVkIiwiaXNSYW5rU29ydGVkIl0sWyJzb3J0QnlSYW5rIiwic29ydEJ5UmFuayJdLFsiY29tcGFyZUFudGlSYW5rIiwiY29tcGFyZUFudGlSYW5rIl0sWyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0Il0sWyJnZXRQYXNzU3R5bGVDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIl0sWyJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaW50ZXJzZWN0UmFua0NvdmVycyJdLFsidW5pb25SYW5rQ292ZXJzIiwidW5pb25SYW5rQ292ZXJzIl1dLCJAZW5kby9wYXNzLXN0eWxlIjpbWyJkZWVwbHlGdWxmaWxsZWQiLCJkZWVwbHlGdWxmaWxsZWQiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlUGFzc2FibGUuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImlzRW5jb2RlZFJlbW90YWJsZSIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsIm1ha2VFbmNvZGVQYXNzYWJsZSIsIm1ha2VQYXNzYWJsZUtpdCIsInBhc3NTdHlsZVByZWZpeGVzIiwicmVjb3JkTmFtZXMiLCJyZWNvcmRWYWx1ZXMiLCJ6ZXJvUGFkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldFRhZyxtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGFzc2VydFJlY29yZCxpc0Vycm9yTGlrZSxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLGIscSxGYWlsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiYXNzZXJ0UmVjb3JkXCIsIFskaM2PX2EgPT4gKGFzc2VydFJlY29yZCA9ICRozY9fYSldXSxbXCJpc0Vycm9yTGlrZVwiLCBbJGjNj19hID0+IChpc0Vycm9yTGlrZSA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcImJcIiwgWyRozY9fYSA9PiAoYiA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtmcm9tRW50cmllcyxpc309T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcblxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnRyb2wtcmVnZXgqL1xuY29uc3QgckMwPS9bXFx4MDAtXFx4MUZdLztcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHN1ZmZpeCBvZiBhIHN0cmluZyBzdGFydGluZyBhdCBhIHBhcnRpY3VsYXIgaW5kZXguXG4gKiBUaGlzIGJvdGggZXhwcmVzc2VzIGludGVudCBhbmQgcG90ZW50aWFsbHkgYXZvaWRzIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODRcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyXG4gKiBAcGFyYW0ge251bWJlcn0gaW5kZXhcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGdldFN1ZmZpeD0oc3RyLGluZGV4KT0+aW5kZXg9PT0wP3N0cjpzdHIuc3Vic3RyaW5nKGluZGV4KTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCwgd2UgaGF2ZSBvbmx5XG4gKiBzdHJpbmctbmFtZWQgb3duIHByb3BlcnRpZXMuIGByZWNvcmROYW1lc2AgcmV0dXJucyB0aG9zZSBuYW1lICpyZXZlcnNlKlxuICogc29ydGVkLCBiZWNhdXNlIHRoYXQncyBob3cgcmVjb3JkcyBhcmUgY29tcGFyZWQsIGVuY29kZWQsIGFuZCBzb3J0ZWQuXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZE5hbWVzPShyZWNvcmQpPT5cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNjAjZGlzY3Vzc2lvbl9yMTAwMzY1NzI0NCovXG4vKiBjb21wYXJlcyB0d28gd2F5cyBvZiByZXZlcnNlIHNvcnRpbmcsIGFuZCBzaG93cyB0aGF0IGAuc29ydCgpLnJldmVyc2UoKWAqL1xuLyogaXMgY3VycmVudGx5IGZhc3RlciBvbiBNb2RkYWJsZSBYUywgd2hpbGUgdGhlIG90aGVyIHdheSwqL1xuLyogYC5zb3J0KHJldmVyc2VDb21wYXJhdG9yKWAsIGlzIGZhc3RlciBvbiB2OC4gV2UgY3VycmVudGx5IGNhcmUgbW9yZSBhYm91dCovXG4vKiBYUyBwZXJmb3JtYW5jZSwgc28gd2UgcmV2ZXJzZSBzb3J0IHVzaW5nIGAuc29ydCgpLnJldmVyc2UoKWAuKi9cbmhhcmRlbigvKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjb3JkKS5zb3J0KCkucmV2ZXJzZSgpKTskaM2PX29uY2UucmVjb3JkTmFtZXMocmVjb3JkTmFtZXMpO1xuaGFyZGVuKHJlY29yZE5hbWVzKTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCBhbmQgYG5hbWVzYCBpcyBgcmVjb3JkTmFtZXMocmVjb3JkKWAsXG4gKiByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcgYXJyYXkgb2YgcHJvcGVydHkgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxUPn0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBuYW1lc1xuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZFZhbHVlcz0ocmVjb3JkLG5hbWVzKT0+XG5oYXJkZW4obmFtZXMubWFwKChuYW1lKT0+cmVjb3JkW25hbWVdKSk7JGjNj19vbmNlLnJlY29yZFZhbHVlcyhyZWNvcmRWYWx1ZXMpO1xuaGFyZGVuKHJlY29yZFZhbHVlcyk7XG5cbmNvbnN0IHplcm9lcz1BcnJheSgxNikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8saSk9PicwJy5yZXBlYXQoaSkpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gblxuICogQHBhcmFtIHtudW1iZXJ9IHNpemVcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICB6ZXJvUGFkPShuLHNpemUpPT57XG5jb25zdCBuU3RyPSBgJHtufWA7XG5jb25zdCBmaWxsTGVuPXNpemUtblN0ci5sZW5ndGg7XG5pZihmaWxsTGVuPT09MClyZXR1cm4gblN0cjtcbmFzc2VydChmaWxsTGVuPjAmJmZpbGxMZW48emVyb2VzLmxlbmd0aCk7XG5yZXR1cm4gYCR7emVyb2VzW2ZpbGxMZW5dfSR7blN0cn1gO1xuIH07JGjNj19vbmNlLnplcm9QYWQoemVyb1BhZCk7XG5oYXJkZW4oemVyb1BhZCk7XG5cbi8qIFRoaXMgaXMgdGhlIEphdmFTY3JpcHQgYW5hbG9nIHRvIGEgQyB1bmlvbjogYSB3YXkgdG8gbWFwIGJldHdlZW4gYSBmbG9hdCBhcyBhKi9cbi8qIG51bWJlciBhbmQgdGhlIGJpdHMgdGhhdCByZXByZXNlbnQgdGhlIGZsb2F0IGFzIGEgYnVmZmVyIGZ1bGwgb2YgYnl0ZXMuICBOb3RlKi9cbi8qIHRoYXQgdGhlIG11dGF0aW9uIG9mIHN0YXRpYyBzdGF0ZSBoZXJlIG1ha2VzIHRoaXMgaW52YWxpZCBKZXNzaWUgY29kZSwgYnV0Ki9cbi8qIGRvaW5nIGl0IHRoaXMgd2F5IHNhdmVzIHRoZSBudWdhdG9yeSBhbmQgZ3JhdHVpdG91cyBhbGxvY2F0aW9ucyB0aGF0IHdvdWxkKi9cbi8qIGhhcHBlbiBldmVyeSB0aW1lIHlvdSBkbyBhIGNvbnZlcnNpb24gLS0gYW5kIGluIHByYWN0aWNhbCB0ZXJtcyBpdCdzIHNhZmUqL1xuLyogYmVjYXVzZSB3ZSBwdXQgdGhlIHZhbHVlIGluIG9uZSBzaWRlIGFuZCB0aGVuIGltbWVkaWF0ZWx5IHRha2UgaXQgb3V0IHRoZSovXG4vKiBvdGhlcjsgdGhlcmUgaXMgbm8gYWN0dWFsIHN0YXRlIHJldGFpbmVkIGluIHRoZSBjbGFzc2ljIHNlbnNlIGFuZCB0aHVzIG5vKi9cbi8qIHJlLWVudHJhbmN5IGlzc3VlLiovXG5jb25zdCBhc051bWJlcj1uZXcgRmxvYXQ2NEFycmF5KDEpO1xuY29uc3QgYXNCaXRzPW5ldyBCaWdVaW50NjRBcnJheShhc051bWJlci5idWZmZXIpO1xuXG4vKiBKYXZhU2NyaXB0IG51bWJlcnMgYXJlIGVuY29kZWQgYnkgb3V0cHV0dGluZyB0aGUgYmFzZS0xNiovXG4vKiByZXByZXNlbnRhdGlvbiBvZiB0aGUgYmluYXJ5IHZhbHVlIG9mIHRoZSB1bmRlcmx5aW5nIElFRUUgZmxvYXRpbmcgcG9pbnQqL1xuLyogcmVwcmVzZW50YXRpb24uICBGb3IgbmVnYXRpdmUgdmFsdWVzLCBhbGwgYml0cyBvZiB0aGlzIHJlcHJlc2VudGF0aW9uIGFyZSovXG4vKiBjb21wbGVtZW50ZWQgcHJpb3IgdG8gdGhlIGJhc2UtMTYgY29udmVyc2lvbiwgd2hpbGUgZm9yIHBvc2l0aXZlIHZhbHVlcywgdGhlKi9cbi8qIHNpZ24gYml0IGlzIGNvbXBsZW1lbnRlZC4gIFRoaXMgZW5zdXJlcyBib3RoIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYmVmb3JlKi9cbi8qIHBvc2l0aXZlIHZhbHVlcyBhbmQgdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgc29ydCBhY2NvcmRpbmcgdG8gdGhlaXIgbmVnYXRpdmUqL1xuLyogbWFnbml0dWRlIHJhdGhlciB0aGFuIHRoZWlyIHBvc2l0aXZlIG1hZ25pdHVkZS4gIFRoaXMgcmVzdWx0cyBpbiBhbiBBU0NJSSovXG4vKiBlbmNvZGluZyB3aG9zZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgaXMgdGhlIHNhbWUgYXMgdGhlIG51bWVyaWMgc29ydCBvcmRlciovXG4vKiBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLiovXG5cbi8qIFRPRE8gQ2hvb3NlIHRoZSBzYW1lIGNhbm9uaWNhbCBOYU4gZW5jb2RpbmcgdGhhdCBjb3NtV2FzbSBhbmQgZXdhc20gY2hvc2UuKi9cbmNvbnN0IENhbm9uaWNhbE5hTkJpdHM9J2ZmZjgwMDAwMDAwMDAwMDAnO1xuXG4vKipcbiAqIEBwYXJhbSB7bnVtYmVyfSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaW5hcnk2ND0obik9Pntcbi8qIE5vcm1hbGl6ZSAtMCB0byAwIGFuZCBOYU4gdG8gYSBjYW5vbmljYWwgZW5jb2RpbmcqL1xuaWYoaXMobiwtMCkpe1xubj0wO1xuIH1lbHNlIGlmKGlzKG4sTmFOKSl7XG5yZXR1cm4gYGYke0Nhbm9uaWNhbE5hTkJpdHN9YDtcbiB9XG5hc051bWJlclswXT1uO1xubGV0IGJpdHM9YXNCaXRzWzBdO1xuaWYobjwwKXtcbmJpdHNePTB4ZmZmZmZmZmZmZmZmZmZmZm47XG4gfWVsc2V7XG5iaXRzXj0weDgwMDAwMDAwMDAwMDAwMDBuO1xuIH1cbnJldHVybiBgZiR7emVyb1BhZChiaXRzLnRvU3RyaW5nKDE2KSwxNil9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGVCaW5hcnk2ND0oZW5jb2RlZCxza2lwPTApPT57XG5lbmNvZGVkLmNoYXJBdChza2lwKT09PSdmJ3x8RmFpbCBgRW5jb2RlZCBudW1iZXIgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IGJpdHM9QmlnSW50KCBgMHgke2dldFN1ZmZpeChlbmNvZGVkLHNraXArMSl9YCk7XG5pZihlbmNvZGVkLmNoYXJBdChza2lwKzEpPCc4Jyl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5hc0JpdHNbMF09Yml0cztcbmNvbnN0IHJlc3VsdD1hc051bWJlclswXTtcbiFpcyhyZXN1bHQsLTApfHxcbkZhaWwgYFVuZXhwZWN0ZWQgbmVnYXRpdmUgemVybzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEVuY29kZSBhIEphdmFTY3JpcHQgYmlnaW50IHVzaW5nIGEgdmFyaWFudCBvZiBFbGlhcyBkZWx0YSBjb2RpbmcsIHdpdGggYW5cbiAqIGluaXRpYWwgY29tcG9uZW50IGZvciB0aGUgbGVuZ3RoIG9mIHRoZSBkaWdpdCBjb3VudCBhcyBhIHVuYXJ5IHN0cmluZywgYVxuICogc2Vjb25kIGNvbXBvbmVudCBmb3IgdGhlIGRlY2ltYWwgZGlnaXQgY291bnQsIGFuZCBhIHRoaXJkIGNvbXBvbmVudCBmb3IgdGhlXG4gKiBkZWNpbWFsIGRpZ2l0cyBwcmVjZWRlZCBieSBhIGdyYXR1aXRvdXMgc2VwYXJhdGluZyBjb2xvbi5cbiAqIFRvIGVuc3VyZSB0aGF0IHRoZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgb2YgZW5jb2RlZCB2YWx1ZXMgbWF0Y2hlcyB0aGVcbiAqIG51bWVyaWMgc29ydCBvcmRlciBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLCB0aGUgY2hhcmFjdGVycyBvZiB0aGUgdW5hcnlcbiAqIHByZWZpeCBhcmUgZGlmZmVyZW50IGZvciBuZWdhdGl2ZSB2YWx1ZXMgKHR5cGUgXCJuXCIgZm9sbG93ZWQgYnkgYW55IG51bWJlciBvZlxuICogXCIjXCJzIFt3aGljaCBzb3J0IGJlZm9yZSBkZWNpbWFsIGRpZ2l0c10pIHZzLiBwb3NpdGl2ZSBhbmQgemVybyB2YWx1ZXMgKHR5cGVcbiAqIFwicFwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2YgXCJ+XCJzIFt3aGljaCBzb3J0IGFmdGVyIGRlY2ltYWwgZGlnaXRzXSkgYW5kXG4gKiBlYWNoIGRlY2ltYWwgZGlnaXQgb2YgdGhlIGVuY29kaW5nIGZvciBhIG5lZ2F0aXZlIHZhbHVlIGlzIHJlcGxhY2VkIHdpdGggaXRzXG4gKiB0ZW4ncyBjb21wbGVtZW50IChzbyB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBvZiB0aGUgc2FtZSBzY2FsZSBzb3J0IGJ5XG4gKiAqZGVzY2VuZGluZyogYWJzb2x1dGUgdmFsdWUpLlxuICpcbiAqIEBwYXJhbSB7YmlnaW50fSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaWdJbnQ9KG4pPT57XG5jb25zdCBhYnM9bjwwbj8tbjpuO1xuY29uc3QgbkRpZ2l0cz1hYnMudG9TdHJpbmcoKS5sZW5ndGg7XG5jb25zdCBsRGlnaXRzPW5EaWdpdHMudG9TdHJpbmcoKS5sZW5ndGg7XG5pZihuPDBuKXtcbnJldHVybiBgbiR7XG4vKiBBIFwiI1wiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJyMnLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgY291bnQgb2YgZGlnaXRzLiovXG4oMTAqKmxEaWdpdHMtbkRpZ2l0cykudG9TdHJpbmcoKS5wYWRTdGFydChsRGlnaXRzLCcwJylcbiB9OiR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgZGlnaXRzLiovXG4oMTBuKipCaWdJbnQobkRpZ2l0cykrbikudG9TdHJpbmcoKS5wYWRTdGFydChuRGlnaXRzLCcwJylcbiB9YDtcbiB9ZWxzZXtcbnJldHVybiBgcCR7XG4vKiBBIFwiflwiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJ34nLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgY291bnQgb2YgZGlnaXRzLiovXG5uRGlnaXRzXG4gfToke1xuLyogVGhlIGRpZ2l0cy4qL1xublxuIH1gO1xuIH1cbiB9O1xuXG5jb25zdCByQmlnSW50UGF5bG9hZD0vKFswLTldKykoOihbMC05XSskfCl8KS9zO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5jb25zdCBkZWNvZGVCaWdJbnQ9KGVuY29kZWQpPT57XG5jb25zdCB0eXBlUHJlZml4PWVuY29kZWQuY2hhckF0KDApOy8qIGZhc3RlciB0aGFuIGVuY29kZWRbMF0qL1xudHlwZVByZWZpeD09PSdwJ3x8XG50eXBlUHJlZml4PT09J24nfHxcbkZhaWwgYEVuY29kZWQgYmlnaW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcblxuY29uc3R7XG5pbmRleDpsRGlnaXRzLFxuMTpzbkRpZ2l0cyxcbjI6dGFpbCxcbjM6ZGlnaXRzfT1cbmVuY29kZWQubWF0Y2gockJpZ0ludFBheWxvYWQpfHxGYWlsIGBEaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5cbnNuRGlnaXRzLmxlbmd0aD09PWxEaWdpdHN8fFxuRmFpbCBgVW5hcnktcHJlZml4ZWQgZGVjaW1hbCBkaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgbkRpZ2l0cz1wYXJzZUludChzbkRpZ2l0cywxMCk7XG5pZih0eXBlUHJlZml4PT09J24nKXtcbi8qIFRPRE8gQXNzZXJ0IHRvIHJlamVjdCBmb3JiaWRkZW4gZW5jb2RpbmdzKi9cbi8qIGxpa2UgXCJuMDpcIiBhbmQgXCJuMDA64oCmXCIgYW5kIFwibjkxOuKAplwiIHRocm91Z2ggXCJuOTk64oCmXCI/Ki9cbm5EaWdpdHM9MTAqKi8qKiBAdHlwZSB7bnVtYmVyfSAqL2xEaWdpdHMtbkRpZ2l0cztcbiB9XG5cbnRhaWwuY2hhckF0KDApPT09JzonfHxGYWlsIGBTZXBhcmF0b3IgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xuZGlnaXRzLmxlbmd0aD09PW5EaWdpdHN8fFxuRmFpbCBgRml4ZWQtbGVuZ3RoIGRpZ2l0IHNlcXVlbmNlIGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmxldCBuPUJpZ0ludChkaWdpdHMpO1xuaWYodHlwZVByZWZpeD09PSduJyl7XG4vKiBUT0RPIEFzc2VydCB0byByZWplY3QgZm9yYmlkZGVuIGVuY29kaW5ncyovXG4vKiBsaWtlIFwibjk6MFwiIGFuZCBcIm44OjAwXCIgYW5kIFwibjg6OTFcIiB0aHJvdWdoIFwibjg6OTlcIj8qL1xubj0tKDEwbioqQmlnSW50KG5EaWdpdHMpLW4pO1xuIH1cblxucmV0dXJuIG47XG4gfTtcblxuLyoqXG4gKiBBIHNwYXJzZSBhcnJheSBmb3Igd2hpY2ggZXZlcnkgcHJlc2VudCBpbmRleCBtYXBzIGEgY29kZSBwb2ludCBpbiB0aGUgQVNDSUlcbiAqIHJhbmdlIHRvIGEgY29ycmVzcG9uZGluZyBlc2NhcGUgc2VxdWVuY2UuXG4gKlxuICogRXNjYXBlcyBhbGwgY2hhcmFjdGVycyBmcm9tIFUrMDAwMCBOVUxMIHRvIFUrMDAxRiBJTkZPUk1BVElPTiBTRVBBUkFUT1IgT05FXG4gKiBsaWtlIGAhPGNoYXJhY3RlciBvZmZzZXQgYnkgMHgyMT5gIHRvIGF2b2lkIEpTT04uc3RyaW5naWZ5IGV4cGFuc2lvbiBhc1xuICogYFxcdUhISEhgLCBhbmQgc3BlY2lhbGx5IGVzY2FwZXMgVSswMDIwIFNQQUNFICh0aGUgYXJyYXkgZWxlbWVudCB0ZXJtaW5hdG9yKVxuICogYXMgYCFfYCBhbmQgVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgKHRoZSBlc2NhcGUgcHJlZml4KSBhcyBgIXxgIChib3RoIGNob3NlblxuICogZm9yIHZpc3VhbCBhcHByb3hpbWF0aW9uKS5cbiAqIFJlbGF0aXZlIGxleGljb2dyYXBoaWMgb3JkZXJpbmcgaXMgcHJlc2VydmVkIGJ5IHRoaXMgbWFwcGluZyBvZiBhbnkgY2hhcmFjdGVyXG4gKiBhdCBvciBiZWZvcmUgYCFgIGluIHRoZSBjb250aWd1b3VzIHJhbmdlIFsweDAwLi4weDIxXSB0byBhIHJlc3BlY3RpdmVcbiAqIGNoYXJhY3RlciBpbiBbMHgyMS4uMHg0MCwgMHg1RiwgMHg3Q10gcHJlY2VkZWQgYnkgYCFgICh3aGljaCBpcyBpdHNlbGYgaW4gdGhlXG4gKiByZXBsYWNlZCByYW5nZSkuXG4gKiBTaW1pbGFybHksIGVzY2FwZXMgYF5gIGFzIGBfQGAgYW5kIGBfYCBhcyBgX19gIGJlY2F1c2UgYF5gIGluZGljYXRlcyB0aGVcbiAqIHN0YXJ0IG9mIGFuIGVuY29kZWQgYXJyYXkuXG4gKlxuICogQHR5cGUge0FycmF5PHN0cmluZz59XG4gKi9cbmNvbnN0IHN0cmluZ0VzY2FwZXM9QXJyYXkoMHgyMikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8sY3ApPT57XG5zd2l0Y2goU3RyaW5nLmZyb21DaGFyQ29kZShjcCkpe1xuY2FzZScgJzpcbnJldHVybichXyc7XG5jYXNlJyEnOlxucmV0dXJuJyF8JztcbmRlZmF1bHQ6XG5yZXR1cm4gYCEke1N0cmluZy5mcm9tQ2hhckNvZGUoY3ArMHgyMSl9YDt9XG5cbiB9KTtcbnN0cmluZ0VzY2FwZXNbJ14nLmNoYXJDb2RlQXQoMCldPSdfQCc7XG5zdHJpbmdFc2NhcGVzWydfJy5jaGFyQ29kZUF0KDApXT0nX18nO1xuXG4vKipcbiAqIEVuY29kZXMgYSBzdHJpbmcgd2l0aCBlc2NhcGUgc2VxdWVuY2VzIGZvciB1c2UgaW4gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhzdHI6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVDb21wYWN0U3RyaW5nU3VmZml4PShzdHIpPT5cbnN0ci5yZXBsYWNlKC9bXFwwLSFeX10vZywoY2gpPT5zdHJpbmdFc2NhcGVzW2NoLmNoYXJDb2RlQXQoMCldKTtcblxuLyoqXG4gKiBEZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhlbmNvZGVkOiBzdHJpbmcpID0+IHN0cmluZ31cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeD0oZW5jb2RlZCk9PntcbnJldHVybiBlbmNvZGVkLnJlcGxhY2UoLyhbXFwwLSFfXSkoLnxcXG4pPy9nLChlc2MscHJlZml4LHN1ZmZpeCk9PntcbnN3aXRjaChlc2Mpe1xuY2FzZSchXyc6XG5yZXR1cm4nICc7XG5jYXNlJyF8JzpcbnJldHVybichJztcbmNhc2UnX0AnOlxucmV0dXJuJ14nO1xuY2FzZSdfXyc6XG5yZXR1cm4nXyc7XG5kZWZhdWx0OntcbmNvbnN0IGNoPS8qKiBAdHlwZSB7c3RyaW5nfSAqL3N1ZmZpeDtcbi8qIFRoZSByYW5nZSBvZiB2YWxpZCBgIWAtZXNjYXBlIHN1ZmZpeGVzIGlzIFsoMHgwMCsweDIxKS4uKDB4MUYrMHgyMSldLCBpLmUuKi9cbi8qIFsweDIxLi4weDQwXSAoVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgdG8gVSswMDQwIENPTU1FUkNJQUwgQVQpLiovXG5wcmVmaXg9PT0nIScmJnN1ZmZpeCE9PXVuZGVmaW5lZCYmY2g+PSchJyYmY2g8PSdAJ3x8XG5GYWlsIGBpbnZhbGlkIHN0cmluZyBlc2NhcGU6ICR7cShlc2MpfWA7XG5yZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZShjaC5jaGFyQ29kZUF0KDApLTB4MjEpO1xuIH19XG5cbiB9KTtcbiB9O1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1lbmNvZGVzIGEgc3RyaW5nIGZvciB1c2UgaW4gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IGVuY29kZUxlZ2FjeVN0cmluZ1N1ZmZpeD0oc3RyKT0+c3RyO1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1kZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBkZWNvZGVMZWdhY3lTdHJpbmdTdWZmaXg9KGVuY29kZWQpPT5lbmNvZGVkO1xuXG4vKipcbiAqIEVuY29kZXMgYW4gYXJyYXkgaW50byBhIHNlcXVlbmNlIG9mIGVuY29kZWQgZWxlbWVudHMgZm9yIHVzZSBpbiB0aGUgXCJjb21wYWN0T3JkZXJlZFwiXG4gKiBmb3JtYXQsIGVhY2ggdGVybWluYXRlZCBieSBhIHNwYWNlICh3aGljaCBpcyBwYXJ0IG9mIHRoZSBlc2NhcGVkIHJhbmdlIGluXG4gKiBcImNvbXBhY3RPcmRlcmVkXCIgZW5jb2RlZCBzdHJpbmdzKS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQ29tcGFjdEFycmF5PShhcnJheSxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IGNoYXJzPVsnXiddO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgYXJyYXkpe1xuY29uc3QgZW5jPWVuY29kZVBhc3NhYmxlKGVsZW1lbnQpO1xuY2hhcnMucHVzaChlbmMsJyAnKTtcbiB9XG5yZXR1cm4gY2hhcnMuam9pbignJyk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHBhcmFtIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX0gZGVjb2RlUGFzc2FibGVcbiAqIEBwYXJhbSB7bnVtYmVyfSBbc2tpcF1cbiAqIEByZXR1cm5zIHtBcnJheX1cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdEFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xubGV0IGRlcHRoPTA7XG4vKiBTY2FuIGVuY29kZWQgcmF0aGVyIHRoYW4gaXRzIHRhaWwgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmxldCBuZXh0SW5kZXg9c2tpcCsxO1xubGV0IGN1cnJlbnRFbGVtZW50U3RhcnQ9c2tpcCsxO1xuZm9yKGNvbnN0ezA6Y2gsaW5kZXg6aX1vZiBlbmNvZGVkLm1hdGNoQWxsKC9bXFxeIF0vZykpe1xuY29uc3QgaW5kZXg9LyoqIEB0eXBlIHtudW1iZXJ9ICovaTtcbmlmKGluZGV4PD1za2lwKXtcbmlmKGluZGV4PT09c2tpcCl7XG5jaD09PSdeJ3x8RmFpbCBgRW5jb2RlZCBhcnJheSBleHBlY3RlZDogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuIH1cbiB9ZWxzZSBpZihjaD09PSdeJyl7XG4vKiBUaGlzIGlzIHRoZSBzdGFydCBvZiBhIG5lc3RlZCBhcnJheS4qL1xuLyogVE9ETzogU2luY2UgdGhlIHN5bnRheCBvZiBuZXN0ZWQgYXJyYXlzIG11c3QgYmUgdmFsaWRhdGVkIGFzIHBhcnQgb2YqL1xuLyogZGVjb2RpbmcgdGhlIG91dGVyIG9uZSwgY29uc2lkZXIgZGVjb2RpbmcgdGhlbSBoZXJlIGludG8gYSBzaGFyZWQgY2FjaGUqL1xuLyogcmF0aGVyIHRoYW4gZGlzY2FyZGluZyBpbmZvcm1hdGlvbiBhYm91dCB0aGVpciBjb250ZW50cyB1bnRpbCB0aGUgbGF0ZXIqL1xuLyogZGVjb2RlUGFzc2FibGUuKi9cbmRlcHRoKz0xO1xuIH1lbHNle1xuLyogVGhpcyBpcyBhIHRlcm1pbmF0ZWQgZWxlbWVudC4qL1xuaWYoaW5kZXg9PT1uZXh0SW5kZXgpe1xuLyogQSB0ZXJtaW5hdG9yIGFmdGVyIGBbYCBvciBhbiBhbm90aGVyIHRlcm1pbmF0b3IgaW5kaWNhdGVzIHRoYXQgYW4gYXJyYXkgaXMgZG9uZS4qL1xuZGVwdGgtPTE7XG5kZXB0aD49MHx8XG4vKiBwcmV0dGllci1pZ25vcmUqL1xuRmFpbCBgdW5leHBlY3RlZCBhcnJheSBlbGVtZW50IHRlcm1pbmF0b3I6ICR7ZW5jb2RlZC5zbGljZShza2lwLGluZGV4KzIpfWA7XG4gfVxuaWYoZGVwdGg9PT0wKXtcbi8qIFdlIGhhdmUgYSBjb21wbGV0ZSBlbGVtZW50IG9mIHRoZSB0b3Btb3N0IGFycmF5LiovXG5lbGVtZW50cy5wdXNoKFxuZGVjb2RlUGFzc2FibGUoZW5jb2RlZC5zbGljZShjdXJyZW50RWxlbWVudFN0YXJ0LGluZGV4KSkpO1xuXG5jdXJyZW50RWxlbWVudFN0YXJ0PWluZGV4KzE7XG4gfVxuIH1cbi8qIEFkdmFuY2UgdGhlIGluZGV4LiovXG5uZXh0SW5kZXg9aW5kZXgrMTtcbiB9XG5kZXB0aD09PTB8fEZhaWwgYHVudGVybWluYXRlZCBhcnJheTogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xubmV4dEluZGV4PT09ZW5jb2RlZC5sZW5ndGh8fFxuRmFpbCBgdW50ZXJtaW5hdGVkIGFycmF5IGVsZW1lbnQ6ICR7Z2V0U3VmZml4KFxuZW5jb2RlZCxcbmN1cnJlbnRFbGVtZW50U3RhcnQpXG4gfWA7XG5yZXR1cm4gaGFyZGVuKGVsZW1lbnRzKTtcbiB9O1xuXG4vKipcbiAqIFBlcmZvcm1zIHRoZSBvcmlnaW5hbCBhcnJheSBlbmNvZGluZywgd2hpY2ggZXNjYXBlcyBhbGwgZW5jb2RlZCBhcnJheVxuICogZWxlbWVudHMgcmF0aGVyIHRoYW4ganVzdCBzdHJpbmdzIChgXFx1MDAwMGAgYXMgdGhlIGVsZW1lbnQgdGVybWluYXRvciBhbmRcbiAqIGBcXHUwMDAxYCBhcyB0aGUgZXNjYXBlIHByZWZpeCBmb3IgYFxcdTAwMDBgIG9yIGBcXHUwMDAxYCkuXG4gKiBUaGlzIG5lY2Vzc2l0YXRlZCBhbiB1bmRlc2lyYWJsZSBhbW91bnQgb2YgaXRlcmF0aW9uIGFuZCBleHBhbnNpb247IHNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI2MCNkaXNjdXNzaW9uX3I5NjAzNjk4MjZcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlTGVnYWN5QXJyYXk9KGFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgY2hhcnM9WydbJ107XG5mb3IoY29uc3QgZWxlbWVudCBvZiBhcnJheSl7XG5jb25zdCBlbmM9ZW5jb2RlUGFzc2FibGUoZWxlbWVudCk7XG5mb3IoY29uc3QgYyBvZiBlbmMpe1xuaWYoYz09PSdcXHUwMDAwJ3x8Yz09PSdcXHUwMDAxJyl7XG5jaGFycy5wdXNoKCdcXHUwMDAxJyk7XG4gfVxuY2hhcnMucHVzaChjKTtcbiB9XG5jaGFycy5wdXNoKCdcXHUwMDAwJyk7XG4gfVxucmV0dXJuIGNoYXJzLmpvaW4oJycpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gUGFzc2FibGV9IGRlY29kZVBhc3NhYmxlXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7QXJyYXl9XG4gKi9cbmNvbnN0IGRlY29kZUxlZ2FjeUFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xuY29uc3QgZWxlbUNoYXJzPVtdO1xuLyogVXNlIGEgc3RyaW5nIGl0ZXJhdG9yIHRvIGF2b2lkIHNsb3cgaW5kZXhlZCBhY2Nlc3MgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5sZXQgc3RpbGxUb1NraXA9c2tpcCsxO1xubGV0IGluRXNjYXBlPWZhbHNlO1xuZm9yKGNvbnN0IGMgb2YgZW5jb2RlZCl7XG5pZihzdGlsbFRvU2tpcD4wKXtcbnN0aWxsVG9Ta2lwLT0xO1xuaWYoc3RpbGxUb1NraXA9PT0wKXtcbmM9PT0nWyd8fEZhaWwgYEVuY29kZWQgYXJyYXkgZXhwZWN0ZWQ6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbiB9XG4gfWVsc2UgaWYoaW5Fc2NhcGUpe1xuYz09PSdcXHUwMDAwJ3x8XG5jPT09J1xcdTAwMDEnfHxcbkZhaWwgYFVuZXhwZWN0ZWQgY2hhcmFjdGVyIGFmdGVyIHUwMDAxIGVzY2FwZTogJHtjfWA7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDAnKXtcbmNvbnN0IGVuY29kZWRFbGVtZW50PWVsZW1DaGFycy5qb2luKCcnKTtcbmVsZW1DaGFycy5sZW5ndGg9MDtcbmNvbnN0IGVsZW1lbnQ9ZGVjb2RlUGFzc2FibGUoZW5jb2RlZEVsZW1lbnQpO1xuZWxlbWVudHMucHVzaChlbGVtZW50KTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDEnKXtcbmluRXNjYXBlPXRydWU7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tY29udGludWUqL1xuY29udGludWU7XG4gfWVsc2V7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9XG5pbkVzY2FwZT1mYWxzZTtcbiB9XG4haW5Fc2NhcGV8fEZhaWwgYHVuZXhwZWN0ZWQgZW5kIG9mIGVuY29kaW5nICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmVsZW1DaGFycy5sZW5ndGg9PT0wfHxcbkZhaWwgYGVuY29kaW5nIHRlcm1pbmF0ZWQgZWFybHk6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbnJldHVybiBoYXJkZW4oZWxlbWVudHMpO1xuIH07XG5cbmNvbnN0IGVuY29kZVJlY29yZD0ocmVjb3JkLGVuY29kZUFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgbmFtZXM9cmVjb3JkTmFtZXMocmVjb3JkKTtcbmNvbnN0IHZhbHVlcz1yZWNvcmRWYWx1ZXMocmVjb3JkLG5hbWVzKTtcbnJldHVybiBgKCR7ZW5jb2RlQXJyYXkoaGFyZGVuKFtuYW1lcyx2YWx1ZXNdKSxlbmNvZGVQYXNzYWJsZSl9YDtcbiB9O1xuXG5jb25zdCBkZWNvZGVSZWNvcmQ9KGVuY29kZWQsZGVjb2RlQXJyYXksZGVjb2RlUGFzc2FibGUsc2tpcD0wKT0+e1xuYXNzZXJ0KGVuY29kZWQuY2hhckF0KHNraXApPT09JygnKTtcbi8qIFNraXAgdGhlIFwiKFwiIGluc2lkZSBgZGVjb2RlQXJyYXlgIHRvIGF2b2lkIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5jb25zdCB1bnppcHBlZEVudHJpZXM9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudW56aXBwZWRFbnRyaWVzLmxlbmd0aD09PTJ8fFxuRmFpbCBgZXhwZWN0ZWQga2V5cyx2YWx1ZXMgcGFpcjogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuY29uc3Rba2V5cyx2YWxzXT11bnppcHBlZEVudHJpZXM7XG5cbnBhc3NTdHlsZU9mKGtleXMpPT09J2NvcHlBcnJheScmJlxucGFzc1N0eWxlT2YodmFscyk9PT0nY29weUFycmF5JyYmXG5rZXlzLmxlbmd0aD09PXZhbHMubGVuZ3RoJiZcbmtleXMuZXZlcnkoKGtleSk9PnR5cGVvZiBrZXk9PT0nc3RyaW5nJyl8fFxuRmFpbCBgbm90IGEgdmFsaWQgcmVjb3JkIGVuY29kaW5nOiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG5jb25zdCBtYXBFbnRyaWVzPWtleXMubWFwKChrZXksaSk9PltrZXksdmFsc1tpXV0pO1xuY29uc3QgcmVjb3JkPWhhcmRlbihmcm9tRW50cmllcyhtYXBFbnRyaWVzKSk7XG5hc3NlcnRSZWNvcmQocmVjb3JkLCdkZWNvZGVkIHJlY29yZCcpO1xucmV0dXJuIHJlY29yZDtcbiB9O1xuXG5jb25zdCBlbmNvZGVUYWdnZWQ9KHRhZ2dlZCxlbmNvZGVBcnJheSxlbmNvZGVQYXNzYWJsZSk9PlxuIGA6JHtlbmNvZGVBcnJheShoYXJkZW4oW2dldFRhZyh0YWdnZWQpLHRhZ2dlZC5wYXlsb2FkXSksZW5jb2RlUGFzc2FibGUpfWA7XG5cbmNvbnN0IGRlY29kZVRhZ2dlZD0oZW5jb2RlZCxkZWNvZGVBcnJheSxkZWNvZGVQYXNzYWJsZSxza2lwPTApPT57XG5hc3NlcnQoZW5jb2RlZC5jaGFyQXQoc2tpcCk9PT0nOicpO1xuLyogU2tpcCB0aGUgXCI6XCIgaW5zaWRlIGBkZWNvZGVBcnJheWAgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmNvbnN0IHRhZ2dlZFBheWxvYWQ9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudGFnZ2VkUGF5bG9hZC5sZW5ndGg9PT0yfHxcbkZhaWwgYGV4cGVjdGVkIHRhZyxwYXlsb2FkIHBhaXI6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmNvbnN0W3RhZyxwYXlsb2FkXT10YWdnZWRQYXlsb2FkO1xucGFzc1N0eWxlT2YodGFnKT09PSdzdHJpbmcnfHxcbkZhaWwgYG5vdCBhIHZhbGlkIHRhZ2dlZCBlbmNvZGluZzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLHBheWxvYWQpO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVSZW1vdGFibGU9KHVuc2FmZUVuY29kZVJlbW90YWJsZSx2ZXJpZnlFbmNvZGluZyk9PntcbmNvbnN0IGVuY29kZVJlbW90YWJsZT0ocixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVJlbW90YWJsZShyLGlubmVyRW5jb2RlKTtcbnR5cGVvZiBlbmNvZGluZz09PSdzdHJpbmcnJiZlbmNvZGluZy5jaGFyQXQoMCk9PT0ncid8fFxuRmFpbCBgUmVtb3RhYmxlIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcInJcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ1JlbW90YWJsZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUmVtb3RhYmxlO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVQcm9taXNlPSh1bnNhZmVFbmNvZGVQcm9taXNlLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlUHJvbWlzZT0ocCxpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVByb21pc2UocCxpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09Jz8nfHxcbkZhaWwgYFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiP1wiOiAke2VuY29kaW5nfWA7XG52ZXJpZnlFbmNvZGluZyhlbmNvZGluZywnUHJvbWlzZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUHJvbWlzZTtcbiB9O1xuXG5jb25zdCBtYWtlRW5jb2RlRXJyb3I9KHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlRXJyb3I9KGVycixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZUVycm9yKGVycixpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09JyEnfHxcbkZhaWwgYEVycm9yIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcIiFcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ0Vycm9yJyk7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfTtcbnJldHVybiBlbmNvZGVFcnJvcjtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVSZW1vdGFibGVdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVQcm9taXNlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVFcnJvcl1cbiAqIEBwcm9wZXJ0eSB7J2xlZ2FjeU9yZGVyZWQnIHwgJ2NvbXBhY3RPcmRlcmVkJ30gW2Zvcm1hdF1cbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9IGVuY29kZVN0cmluZ1N1ZmZpeFxuICogQHBhcmFtIHsoYXJyOiB1bmtub3duW10sIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZykgPT4gc3RyaW5nfSBlbmNvZGVBcnJheVxuICogQHBhcmFtIHtSZXF1aXJlZDxFbmNvZGVPcHRpb25zPiAmIHt2ZXJpZnlFbmNvZGluZz86IChlbmNvZGVkOiBzdHJpbmcsIGxhYmVsOiBzdHJpbmcpID0+IHZvaWR9fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KHA6IFBhc3NhYmxlKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckVuY29kZT0oZW5jb2RlU3RyaW5nU3VmZml4LGVuY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZTp1bnNhZmVFbmNvZGVSZW1vdGFibGUsXG5lbmNvZGVQcm9taXNlOnVuc2FmZUVuY29kZVByb21pc2UsXG5lbmNvZGVFcnJvcjp1bnNhZmVFbmNvZGVFcnJvcixcbnZlcmlmeUVuY29kaW5nPSgpPT57IH19PVxub3B0aW9ucztcbmNvbnN0IGVuY29kZVJlbW90YWJsZT1tYWtlRW5jb2RlUmVtb3RhYmxlKFxudW5zYWZlRW5jb2RlUmVtb3RhYmxlLFxudmVyaWZ5RW5jb2RpbmcpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlPW1ha2VFbmNvZGVQcm9taXNlKHVuc2FmZUVuY29kZVByb21pc2UsdmVyaWZ5RW5jb2RpbmcpO1xuY29uc3QgZW5jb2RlRXJyb3I9bWFrZUVuY29kZUVycm9yKHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKTtcblxuY29uc3QgaW5uZXJFbmNvZGU9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gZW5jb2RlRXJyb3IocGFzc2FibGUsaW5uZXJFbmNvZGUpO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXNzYWJsZSk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnbnVsbCc6e1xucmV0dXJuJ3YnO1xuIH1cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm4neic7XG4gfVxuY2FzZSdudW1iZXInOntcbnJldHVybiBlbmNvZGVCaW5hcnk2NChwYXNzYWJsZSk7XG4gfVxuY2FzZSdzdHJpbmcnOntcbnJldHVybiBgcyR7ZW5jb2RlU3RyaW5nU3VmZml4KHBhc3NhYmxlKX1gO1xuIH1cbmNhc2UnYm9vbGVhbic6e1xucmV0dXJuIGBiJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gZW5jb2RlQmlnSW50KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xucmV0dXJuIGVuY29kZVJlbW90YWJsZShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIGVuY29kZUVycm9yKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBlbmNvZGVQcm9taXNlKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuLyogU3RyaW5ncyBhbmQgc3ltYm9scyBzaGFyZSBlbmNvZGluZyBsb2dpYy4qL1xuY29uc3QgbmFtZT1uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbnJldHVybiBgeSR7ZW5jb2RlU3RyaW5nU3VmZml4KG5hbWUpfWA7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbnJldHVybiBlbmNvZGVBcnJheShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG5yZXR1cm4gZW5jb2RlUmVjb3JkKHBhc3NhYmxlLGVuY29kZUFycmF5LGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJuIGVuY29kZVRhZ2dlZChwYXNzYWJsZSxlbmNvZGVBcnJheSxpbm5lckVuY29kZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBhICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgdXNlZCBhcyBhIGNvbGxlY3Rpb24gcGFzc2FibGVgO1xuIH19XG5cbiB9O1xucmV0dXJuIGlubmVyRW5jb2RlO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yXVxuICovXG5cbmNvbnN0IGxpYmVyYWxEZWNvZGVycz0vKiogQHR5cGUge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSAqL1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL3tcbmRlY29kZVJlbW90YWJsZTooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZCxcbmRlY29kZVByb21pc2U6KF9lbmNvZGluZyxfaW5uZXJEZWNvZGUpPT51bmRlZmluZWQsXG5kZWNvZGVFcnJvcjooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZH07XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfSBkZWNvZGVTdHJpbmdTdWZmaXhcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZywgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlLCBza2lwPzogbnVtYmVyKSA9PiB1bmtub3duW119IGRlY29kZUFycmF5XG4gKiBAcGFyYW0ge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckRlY29kZT0oZGVjb2RlU3RyaW5nU3VmZml4LGRlY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVSZW1vdGFibGUsZGVjb2RlUHJvbWlzZSxkZWNvZGVFcnJvcn09b3B0aW9ucztcbi8qKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9ICovXG5jb25zdCBpbm5lckRlY29kZT0oZW5jb2RlZCxza2lwPTApPT57XG5zd2l0Y2goZW5jb2RlZC5jaGFyQXQoc2tpcCkpe1xuY2FzZSd2Jzp7XG5yZXR1cm4gbnVsbDtcbiB9XG5jYXNlJ3onOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdmJzp7XG5yZXR1cm4gZGVjb2RlQmluYXJ5NjQoZW5jb2RlZCxza2lwKTtcbiB9XG5jYXNlJ3MnOntcbnJldHVybiBkZWNvZGVTdHJpbmdTdWZmaXgoZ2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKSk7XG4gfVxuY2FzZSdiJzp7XG5jb25zdCBzdWJzdHJpbmc9Z2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKTtcbmlmKHN1YnN0cmluZz09PSd0cnVlJyl7XG5yZXR1cm4gdHJ1ZTtcbiB9ZWxzZSBpZihzdWJzdHJpbmc9PT0nZmFsc2UnKXtcbnJldHVybiBmYWxzZTtcbiB9XG50aHJvdyBGYWlsIGBleHBlY3RlZCBlbmNvZGVkIGJvb2xlYW4gdG8gYmUgXCJidHJ1ZVwiIG9yIFwiYmZhbHNlXCI6ICR7c3Vic3RyaW5nfWA7XG4gfVxuY2FzZSduJzpcbmNhc2UncCc6e1xucmV0dXJuIGRlY29kZUJpZ0ludChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSk7XG4gfVxuY2FzZSdyJzp7XG5yZXR1cm4gZGVjb2RlUmVtb3RhYmxlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJz8nOntcbnJldHVybiBkZWNvZGVQcm9taXNlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJyEnOntcbnJldHVybiBkZWNvZGVFcnJvcihnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSxpbm5lckRlY29kZSk7XG4gfVxuY2FzZSd5Jzp7XG4vKiBTdHJpbmdzIGFuZCBzeW1ib2xzIHNoYXJlIGRlY29kaW5nIGxvZ2ljLiovXG5jb25zdCBuYW1lPWRlY29kZVN0cmluZ1N1ZmZpeChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKzEpKTtcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG4gfVxuY2FzZSdbJzpcbmNhc2UnXic6e1xuLyogQHRzLWV4cGVjdC1lcnJvciBUeXBlICd1bmtub3duW10nIGlzIG5vdCBQYXNzYWJsZSovXG5yZXR1cm4gZGVjb2RlQXJyYXkoZW5jb2RlZCxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJygnOntcbnJldHVybiBkZWNvZGVSZWNvcmQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJzonOntcbnJldHVybiBkZWNvZGVUYWdnZWQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYGludmFsaWQgZGF0YWJhc2Uga2V5OiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaW5uZXJEZWNvZGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXNzYWJsZUtpdFxuICogQHByb3BlcnR5IHtSZXR1cm5UeXBlPG1ha2VJbm5lckVuY29kZT59IGVuY29kZVBhc3NhYmxlXG4gKiBAcHJvcGVydHkge1JldHVyblR5cGU8bWFrZUlubmVyRGVjb2RlPn0gZGVjb2RlUGFzc2FibGVcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlT3B0aW9ucyAmIERlY29kZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhc3NhYmxlS2l0PShvcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGU9KHIsXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3J9YCxcbmVuY29kZVByb21pc2U9KHAsXyk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwfWAsXG5lbmNvZGVFcnJvcj0oZXJyLF8pPT5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke2Vycn1gLFxuZm9ybWF0PSdsZWdhY3lPcmRlcmVkJyxcblxuZGVjb2RlUmVtb3RhYmxlPShlbmNvZGluZyxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZVByb21pc2U9KGVuY29kaW5nLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZUVycm9yPShlbmNvZGluZyxfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gfT1cbm9wdGlvbnM7XG5cbi8qKiBAdHlwZSB7UGFzc2FibGVLaXRbJ2VuY29kZVBhc3NhYmxlJ119ICovXG5sZXQgZW5jb2RlUGFzc2FibGU7XG5jb25zdCBlbmNvZGVPcHRpb25zPXtlbmNvZGVSZW1vdGFibGUsZW5jb2RlUHJvbWlzZSxlbmNvZGVFcnJvcixmb3JtYXR9O1xuaWYoZm9ybWF0PT09J2NvbXBhY3RPcmRlcmVkJyl7XG5jb25zdCBsaWJlcmFsRGVjb2RlPW1ha2VJbm5lckRlY29kZShcbmRlY29kZUNvbXBhY3RTdHJpbmdTdWZmaXgsXG5kZWNvZGVDb21wYWN0QXJyYXksXG5saWJlcmFsRGVjb2RlcnMpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGluZ1xuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgdmVyaWZ5RW5jb2Rpbmc9KGVuY29kaW5nLGxhYmVsKT0+e1xuIWVuY29kaW5nLm1hdGNoKHJDMCl8fFxuRmFpbCBgJHtiKFxubGFiZWwpXG4gfSBlbmNvZGluZyBtdXN0IG5vdCBjb250YWluIGEgQzAgY29udHJvbCBjaGFyYWN0ZXI6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRlY29kZWQ9ZGVjb2RlQ29tcGFjdEFycmF5KCBgXnYgJHtlbmNvZGluZ30gdiBgLGxpYmVyYWxEZWNvZGUpO1xuaXNBcnJheShkZWNvZGVkKSYmXG5kZWNvZGVkLmxlbmd0aD09PTMmJlxuZGVjb2RlZFswXT09PW51bGwmJlxuZGVjb2RlZFsyXT09PW51bGx8fFxuRmFpbCBgJHtiKGxhYmVsKX0gZW5jb2RpbmcgbXVzdCBiZSBlbWJlZGRhYmxlOiAke2VuY29kaW5nfWA7XG4gfTtcbmNvbnN0IGVuY29kZUNvbXBhY3Q9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmVuY29kZUNvbXBhY3RBcnJheSxcbnsuLi5lbmNvZGVPcHRpb25zLHZlcmlmeUVuY29kaW5nfSk7XG5cbmVuY29kZVBhc3NhYmxlPShwYXNzYWJsZSk9PiBgfiR7ZW5jb2RlQ29tcGFjdChwYXNzYWJsZSl9YDtcbiB9ZWxzZSBpZihmb3JtYXQ9PT0nbGVnYWN5T3JkZXJlZCcpe1xuZW5jb2RlUGFzc2FibGU9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZW5jb2RlTGVnYWN5QXJyYXksXG5lbmNvZGVPcHRpb25zKTtcblxuIH1lbHNle1xudGhyb3cgRmFpbCBgVW5yZWNvZ25pemVkIGZvcm1hdDogJHtxKGZvcm1hdCl9YDtcbiB9XG5cbmNvbnN0IGRlY29kZU9wdGlvbnM9e2RlY29kZVJlbW90YWJsZSxkZWNvZGVQcm9taXNlLGRlY29kZUVycm9yfTtcbmNvbnN0IGRlY29kZUNvbXBhY3Q9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmRlY29kZUNvbXBhY3RBcnJheSxcbmRlY29kZU9wdGlvbnMpO1xuXG5jb25zdCBkZWNvZGVMZWdhY3k9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZGVjb2RlTGVnYWN5QXJyYXksXG5kZWNvZGVPcHRpb25zKTtcblxuY29uc3QgZGVjb2RlUGFzc2FibGU9KGVuY29kZWQpPT57XG4vKiBBIGxlYWRpbmcgXCJ+XCIgaW5kaWNhdGVzIHRoZSB2MiBlbmNvZGluZyAod2l0aCBlc2NhcGluZyBpbiBzdHJpbmdzIHJhdGhlciB0aGFuIGFycmF5cykuKi9cbi8qIFNraXAgaXQgaW5zaWRlIGBkZWNvZGVDb21wYWN0YCB0byBhdm9pZCBzbG93IGBzdWJzdHJpbmdgIGluIFhTLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODQqL1xuaWYoZW5jb2RlZC5jaGFyQXQoMCk9PT0nficpe1xucmV0dXJuIGRlY29kZUNvbXBhY3QoZW5jb2RlZCwxKTtcbiB9XG5yZXR1cm4gZGVjb2RlTGVnYWN5KGVuY29kZWQpO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe2VuY29kZVBhc3NhYmxlLGRlY29kZVBhc3NhYmxlfSk7XG4gfTskaM2PX29uY2UubWFrZVBhc3NhYmxlS2l0KG1ha2VQYXNzYWJsZUtpdCk7XG5oYXJkZW4obWFrZVBhc3NhYmxlS2l0KTtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0WydlbmNvZGVQYXNzYWJsZSddfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVBhc3NhYmxlPShlbmNvZGVPcHRpb25zKT0+e1xuY29uc3R7ZW5jb2RlUGFzc2FibGV9PW1ha2VQYXNzYWJsZUtpdChlbmNvZGVPcHRpb25zKTtcbnJldHVybiBlbmNvZGVQYXNzYWJsZTtcbiB9OyRozY9fb25jZS5tYWtlRW5jb2RlUGFzc2FibGUobWFrZUVuY29kZVBhc3NhYmxlKTtcbmhhcmRlbihtYWtlRW5jb2RlUGFzc2FibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7RGVjb2RlT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7UGFzc2FibGVLaXRbJ2RlY29kZVBhc3NhYmxlJ119XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlUGFzc2FibGU9KGRlY29kZU9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVQYXNzYWJsZX09bWFrZVBhc3NhYmxlS2l0KGRlY29kZU9wdGlvbnMpO1xucmV0dXJuIGRlY29kZVBhc3NhYmxlO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVQYXNzYWJsZShtYWtlRGVjb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5cbmNvbnN0ICAgICAgICBpc0VuY29kZWRSZW1vdGFibGU9KGVuY29kZWQpPT5lbmNvZGVkLmNoYXJBdCgwKT09PSdyJzskaM2PX29uY2UuaXNFbmNvZGVkUmVtb3RhYmxlKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5oYXJkZW4oaXNFbmNvZGVkUmVtb3RhYmxlKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlIHtSZWNvcmQ8UGFzc1N0eWxlLCBzdHJpbmc+fVxuICogVGhlIHNpbmdsZSBwcmVmaXggY2hhcmFjdGVycyB0byBiZSB1c2VkIGZvciBlYWNoIFBhc3NTdHlsZSBjYXRlZ29yeS5cbiAqIGBiaWdpbnRgIGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBlYWNoIG9mIHRob3NlIGNoYXJhY3RlcnNcbiAqIGluZGl2aWR1YWxseSBpcyBhIHZhbGlkIGJpZ2ludCBwcmVmaXggKGBuYCBmb3IgXCJuZWdhdGl2ZVwiIGFuZCBgcGAgZm9yXG4gKiBcInBvc2l0aXZlXCIpLCBhbmQgY29weUFycmF5IGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBvbmUgZW5jb2RpbmdcbiAqIHByZWZpeGVzIGFycmF5cyB3aXRoIGBbYCB3aGlsZSB0aGUgb3RoZXIgdXNlcyBgXmAgKHdoaWNoIGlzIHByb2hpYml0ZWQgZnJvbVxuICogYXBwZWFyaW5nIGluIGFuIGVuY29kZWQgc3RyaW5nKS5cbiAqIFRoZSBvcmRlcmluZyBvZiB0aGVzZSBwcmVmaXhlcyBpcyB0aGUgc2FtZSBhcyB0aGUgcmFua09yZGVyaW5nIG9mIHRoZWlyXG4gKiByZXNwZWN0aXZlIFBhc3NTdHlsZXMsIGFuZCByYW5rT3JkZXIuanMgaW1wb3J0cyB0aGUgdGFibGUgZm9yIHRoaXMgcHVycG9zZS5cbiAqXG4gKiBJbiBhZGRpdGlvbiwgYHxgIGlzIHRoZSByZW1vdGFibGUtPm9yZGluYWwgbWFwcGluZyBwcmVmaXg6XG4gKiBUaGlzIGlzIG5vdCB1c2VkIGluIGNvdmVycyBidXQgaXQgaXNcbiAqIHJlc2VydmVkIGZyb20gdGhlIHNhbWUgc2V0IG9mIHN0cmluZ3MuIE5vdGUgdGhhdCB0aGUgcHJlZml4IGlzID4gYW55XG4gKiBwcmVmaXggdXNlZCBieSBhbnkgY292ZXIgc28gdGhhdCBvcmRpbmFsIG1hcHBpbmcga2V5cyBhcmUgYWx3YXlzIG91dHNpZGVcbiAqIHRoZSByYW5nZSBvZiB2YWxpZCBjb2xsZWN0aW9uIGVudHJ5IGtleXMuXG4gKi9cbmNvbnN0ICAgICAgICBwYXNzU3R5bGVQcmVmaXhlcz17XG5lcnJvcjonIScsXG5jb3B5UmVjb3JkOicoJyxcbnRhZ2dlZDonOicsXG5wcm9taXNlOic/JyxcbmNvcHlBcnJheTonW14nLFxuYm9vbGVhbjonYicsXG5udW1iZXI6J2YnLFxuYmlnaW50OiducCcsXG5yZW1vdGFibGU6J3InLFxuc3RyaW5nOidzJyxcbm51bGw6J3YnLFxuc3ltYm9sOid5Jyxcbi8qIEJlY2F1c2UgQXJyYXkucHJvdG90eXBlLnNvcnQgcHV0cyB1bmRlZmluZWQgdmFsdWVzIGF0IHRoZSBlbmQgd2l0aG91dCovXG4vKiBwYXNzaW5nIHRoZW0gdG8gYSBjb21wYXJpc29uIGZ1bmN0aW9uLCB1bmRlZmluZWQgTVVTVCBiZSB0aGUgbGFzdCovXG4vKiBjYXRlZ29yeS4qL1xudW5kZWZpbmVkOid6J307JGjNj19vbmNlLnBhc3NTdHlsZVByZWZpeGVzKHBhc3NTdHlsZVByZWZpeGVzKTtcblxuT2JqZWN0LnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVByZWZpeGVzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVByZWZpeGVzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlY29yZE5hbWVzIjpbInJlY29yZE5hbWVzIl0sInJlY29yZFZhbHVlcyI6WyJyZWNvcmRWYWx1ZXMiXSwiemVyb1BhZCI6WyJ6ZXJvUGFkIl0sIm1ha2VQYXNzYWJsZUtpdCI6WyJtYWtlUGFzc2FibGVLaXQiXSwibWFrZUVuY29kZVBhc3NhYmxlIjpbIm1ha2VFbmNvZGVQYXNzYWJsZSJdLCJtYWtlRGVjb2RlUGFzc2FibGUiOlsibWFrZURlY29kZVBhc3NhYmxlIl0sImlzRW5jb2RlZFJlbW90YWJsZSI6WyJpc0VuY29kZWRSZW1vdGFibGUiXSwicGFzc1N0eWxlUHJlZml4ZXMiOlsicGFzc1N0eWxlUHJlZml4ZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAMYqu5Eo6AABKOgAAKwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb0NhcERhdGEuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIlFDTEFTUyIsIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSIsIm1ha2VFbmNvZGVUb0NhcERhdGEiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxpc09iamVjdCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLFgsRmFpbCxxOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRozY9fYSA9PiAoaXNFcnJvckxpa2UgPSAkaM2PX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjNj19hID0+IChtYWtlVGFnZ2VkID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImdldFRhZ1wiLCBbJGjNj19hID0+IChnZXRUYWcgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaM2PX2EgPT4gKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzYWJsZSwgUmVtb3RhYmxlT2JqZWN0fSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuLyoqIEBpbXBvcnQge0VuY29kaW5nLCBFbmNvZGluZ1VuaW9ufSBmcm9tICcuL3R5cGVzLmpzJyAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsXG5kZWZpbmVQcm9wZXJ0aWVzLFxuaXMsXG5lbnRyaWVzLFxuZnJvbUVudHJpZXMsXG5mcmVlemV9PVxuT2JqZWN0O1xuXG4vKipcbiAqIFNwZWNpYWwgcHJvcGVydHkgbmFtZSB0aGF0IGluZGljYXRlcyBhbiBlbmNvZGluZyB0aGF0IG5lZWRzIHNwZWNpYWxcbiAqIGRlY29kaW5nLlxuICovXG5jb25zdCBRQ0xBU1M9J0BxY2xhc3MnOyRozY9fb25jZS5RQ0xBU1MoUUNMQVNTKTtcblxuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEByZXR1cm5zIHtlbmNvZGVkIGlzIEVuY29kaW5nVW5pb259XG4gKi9cbmNvbnN0IGhhc1FDbGFzcz0oZW5jb2RlZCk9Pmhhc093blByb3BlcnR5T2YoZW5jb2RlZCxRQ0xBU1MpO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7c3RyaW5nfSBxY2xhc3NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBxY2xhc3NNYXRjaGVzPShlbmNvZGVkLHFjbGFzcyk9PlxuaXNPYmplY3QoZW5jb2RlZCkmJlxuIWlzQXJyYXkoZW5jb2RlZCkmJlxuaGFzUUNsYXNzKGVuY29kZWQpJiZcbmVuY29kZWRbUUNMQVNTXT09PXFjbGFzcztcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVUb0NhcERhdGFPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGVPYmplY3QsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlRXJyb3JUb0NhcERhdGFdXG4gKi9cblxuY29uc3QgZG9udEVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT0ocmVtKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9tKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YDtcblxuY29uc3QgZG9udEVuY29kZUVycm9yVG9DYXBEYXRhPShlcnIpPT5GYWlsIGBlcnJvciBvYmplY3QgdW5leHBlY3RlZDogJHtlcnJ9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZVRvQ2FwRGF0YU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IEVuY29kaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVRvQ2FwRGF0YT0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhPWRvbnRFbmNvZGVSZW1vdGFibGVUb0NhcERhdGEsXG5lbmNvZGVQcm9taXNlVG9DYXBEYXRhPWRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhLFxuZW5jb2RlRXJyb3JUb0NhcERhdGE9ZG9udEVuY29kZUVycm9yVG9DYXBEYXRhfT1cbmVuY29kZU9wdGlvbnM7XG5cbi8qKlxuICogTXVzdCBlbmNvZGUgYHZhbGAgaW50byBwbGFpbiBKU09OIGRhdGEgKmNhbm9uaWNhbGx5Kiwgc3VjaCB0aGF0XG4gKiBgSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSkgPT09IEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpYC4gRm9yIG1vc3RcbiAqIGVuY29kaW5ncywgdGhlIG9yZGVyIG9mIHByb3BlcnRpZXMgb2YgZWFjaCBub2RlIG9mIHRoZSBvdXRwdXRcbiAqIHN0cnVjdHVyZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhbGdvcml0aG0gYmVsb3cgd2l0aG91dCBzcGVjaWFsXG4gKiBhcnJhbmdlbWVudCwgdXN1YWxseSBieSBiZWluZyBleHByZXNzZWQgZGlyZWN0bHkgYXMgYW4gb2JqZWN0IGxpdGVyYWwuXG4gKiBUaGUgZXhjZXB0aW9uIGlzIGNvcHlSZWNvcmRzLCB3aG9zZSBuYXR1cmFsIGVudW1lcmF0aW9uIG9yZGVyXG4gKiBjYW4gZGlmZmVyIGJldHdlZW4gY29weVJlY29yZHMgdGhhdCBvdXIgZGlzdHJpYnV0ZWQgb2JqZWN0IHNlbWFudGljc1xuICogY29uc2lkZXJzIHRvIGJlIGVxdWl2YWxlbnQuXG4gKiBTaW5jZSwgZm9yIGVhY2ggY29weVJlY29yZCwgd2Ugb25seSBhY2NlcHQgc3RyaW5nIHByb3BlcnR5IG5hbWVzLFxuICogbm90IHN5bWJvbHMsIHdlIGNhbiBjYW5vbmljYWxseSBzb3J0IHRoZSBuYW1lcyBmaXJzdC5cbiAqIEpTT04uc3RyaW5naWZ5IHdpbGwgdGhlbiB2aXNpdCB0aGVzZSBpbiB0aGF0IHNvcnRlZCBvcmRlci5cbiAqXG4gKiBFbmNvZGluZyB3aXRoIGEgY2Fub25pY2FsLUpTT04gZW5jb2RlciB3b3VsZCBhbHNvIHNvbHZlIHRoaXMgY2Fub25pY2FsbmVzc1xuICogcHJvYmxlbSBpbiBhIG1vcmUgbW9kdWxhciBhbmQgZW5jYXBzdWxhdGVkIG1hbm5lci4gTm90ZSB0aGF0IHRoZVxuICogYWN0dWFsIG9yZGVyIHByb2R1Y2VkIGhlcmUsIHRob3VnaCBpdCBhZ3JlZXMgd2l0aCBjYW5vbmljYWwtSlNPTiBvblxuICogY29weVJlY29yZCBwcm9wZXJ0eSBvcmRlcmluZywgZGlmZmVycyBmcm9tIGNhbm9uaWNhbC1KU09OIGFzIGEgd2hvbGVcbiAqIGluIHRoYXQgdGhlIG90aGVyIHJlY29yZCBwcm9wZXJ0aWVzIGFyZSB2aXNpdGVkIGluIHRoZSBvcmRlciBpbiB3aGljaFxuICogdGhleSBhcmUgbGl0ZXJhbGx5IHdyaXR0ZW4gYmVsb3cuIFRPRE8gcGVyaGFwcyB3ZSBzaG91bGQgaW5kZWVkIHN3aXRjaFxuICogdG8gYSBjYW5vbmljYWwgSlNPTiBlbmNvZGVyLCBhbmQgbm90IGRlbGljYXRlbHkgZGVwZW5kIG9uIHRoZSBvcmRlclxuICogaW4gd2hpY2ggdGhlc2Ugb2JqZWN0IGxpdGVyYWxzIGFyZSB3cml0dGVuLlxuICpcbiAqIFJlYWRlcnMgbXVzdCBub3QgY2FyZSBhYm91dCB0aGlzIG9yZGVyIGFueXdheS4gV2UgaW1wb3NlIHRoaXMgcmVxdWlyZW1lbnRcbiAqIG1haW5seSB0byByZWR1Y2Ugbm9uLWRldGVybWluaXNtIGV4cG9zZWQgb3V0c2lkZSBhIHZhdC5cbiAqXG4gKiBAcGFyYW0ge2FueX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHtFbmNvZGluZ30gZXhjZXB0IHRoYXQgYGVuY29kZVRvQ2FwRGF0YWAgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb0NhcERhdGFgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb0NhcERhdGFSZWN1cj0ocGFzc2FibGUpPT57XG4vKiBGaXJzdCB3ZSBoYW5kbGUgYWxsIHByaW1pdGl2ZXMuIFNvbWUgY2FuIGJlIHJlcHJlc2VudGVkIGRpcmVjdGx5IGFzKi9cbi8qIEpTT04sIGFuZCBzb21lIG11c3QgYmUgZW5jb2RlZCBhcyBbUUNMQVNTXSBjb21wb3NpdGVzLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybntbUUNMQVNTXTondW5kZWZpbmVkJ307XG4gfVxuY2FzZSdudW1iZXInOntcbi8qIFNwZWNpYWwtY2FzZSBudW1iZXJzIHdpdGggbm8gZGlnaXQtYmFzZWQgcmVwcmVzZW50YXRpb24uKi9cbmlmKE51bWJlci5pc05hTihwYXNzYWJsZSkpe1xucmV0dXJue1tRQ0xBU1NdOidOYU4nfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybntbUUNMQVNTXTonSW5maW5pdHknfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106Jy1JbmZpbml0eSd9O1xuIH1cbi8qIFBhc3MgdGhyb3VnaCBldmVyeXRoaW5nIGVsc2UsIHJlcGxhY2luZyAtMCB3aXRoIDAuKi9cbnJldHVybiBpcyhwYXNzYWJsZSwtMCk/MDpwYXNzYWJsZTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJue1xuW1FDTEFTU106J2JpZ2ludCcsXG5kaWdpdHM6U3RyaW5nKHBhc3NhYmxlKX07XG5cbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJue1xuW1FDTEFTU106J3N5bWJvbCcsXG5uYW1lfTtcblxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaGFzT3duUHJvcGVydHlPZihwYXNzYWJsZSxRQ0xBU1MpKXtcbi8qIEhpbGJlcnQgaG90ZWwqL1xuY29uc3R7W1FDTEFTU106cWNsYXNzVmFsdWUsLi4ucmVzdH09cGFzc2FibGU7XG4vKiogQHR5cGUge0VuY29kaW5nfSAqL1xuY29uc3QgcmVzdWx0PXtcbltRQ0xBU1NdOidoaWxiZXJ0Jyxcbm9yaWdpbmFsOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHFjbGFzc1ZhbHVlKX07XG5cbmlmKG93bktleXMocmVzdCkubGVuZ3RoPj0xKXtcbi8qIFdlIGhhcmRlbiB0aGUgZW50aXJlIGNhcERhdGEgZW5jb2RpbmcgYmVmb3JlIHdlIHJldHVybiBpdC4qL1xuLyogYGVuY29kZVRvQ2FwRGF0YWAgcmVxdWlyZXMgdGhhdCBpdHMgaW5wdXQgYmUgUGFzc2FibGUsIGFuZCovXG4vKiB0aGVyZWZvcmUgaGFyZGVuZWQuKi9cbi8qIFRoZSBgZnJlZXplYCBoZXJlIGlzIG5lZWRlZCBhbnl3YXksIGJlY2F1c2UgdGhlIGByZXN0YCBpcyovXG4vKiBmcmVzaGx5IGNvbnN0cnVjdGVkIGJ5IHRoZSBgLi4uYCBhYm92ZSwgYW5kIHdlJ3JlIHVzaW5nIGl0Ki9cbi8qIGFzIGltcHV0IGluIGFub3RoZXIgY2FsbCB0byBgZW5jb2RlVG9DYXBEYXRhYC4qL1xucmVzdWx0LnJlc3Q9ZW5jb2RlVG9DYXBEYXRhUmVjdXIoZnJlZXplKHJlc3QpKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEN1cnJlbnRseSBjb3B5UmVjb3JkIGFsbG93cyBvbmx5IHN0cmluZyBrZXlzIHNvIHRoaXMgd2lsbCovXG4vKiB3b3JrLiBJZiB3ZSBhbGxvdyBzb3J0YWJsZSBzeW1ib2wga2V5cywgdGhpcyB3aWxsIG5lZWQgdG8qL1xuLyogYmVjb21lIG1vcmUgaW50ZXJlc3RpbmcuKi9cbmNvbnN0IG5hbWVzPW93bktleXMocGFzc2FibGUpLnNvcnQoKTtcbnJldHVybiBmcm9tRW50cmllcyhcbm5hbWVzLm1hcCgobmFtZSk9PltuYW1lLGVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlW25hbWVdKV0pKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuW1FDTEFTU106J3RhZ2dlZCcsXG50YWc6Z2V0VGFnKHBhc3NhYmxlKSxcbnBheWxvYWQ6ZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhKFxucGFzc2FibGUsXG5lbmNvZGVUb0NhcERhdGFSZWN1cik7XG5cbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MpXG4gfSAke3EoJ3Nsb3QnKX06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgZW5jb2RlZD1lbmNvZGVQcm9taXNlVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTLFxuJ3Nsb3QnKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlRXJyb3JUb0NhcERhdGEocGFzc2FibGUsZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuaWYocWNsYXNzTWF0Y2hlcyhlbmNvZGVkLCdlcnJvcicpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidlcnJvcicpXG4gfTogJHtlbmNvZGVkfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYGludGVybmFsOiBVbnJlY29nbml6ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5jb25zdCBlbmNvZGVUb0NhcERhdGE9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gaGFyZGVuKGVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKSk7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZSkpO1xuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvQ2FwRGF0YShtYWtlRW5jb2RlVG9DYXBEYXRhKTtcbmhhcmRlbihtYWtlRW5jb2RlVG9DYXBEYXRhKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVQcm9taXNlRnJvbUNhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gRXJyb3J9IFtkZWNvZGVFcnJvckZyb21DYXBEYXRhXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0oc2xvdEVuY29kaW5nKT0+XG5GYWlsIGByZW1vdGFibGUgb3IgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Nsb3RFbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbUNhcERhdGE9KGVycm9yRW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyb3JFbmNvZGluZ31gO1xuXG4vKipcbiAqIFRoZSBjdXJyZW50IGVuY29kaW5nIGRvZXMgbm90IGdpdmUgdGhlIGRlY29kZXIgZW5vdWdoIGludG8gdG8gZGlzdGluZ3Vpc2hcbiAqIHdoZXRoZXIgYSBzbG90IHJlcHJlc2VudHMgYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLiBBcyBhbiBpbXBsZW1lbnRhdGlvblxuICogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmVcbiAqIHByb3ZpZGVkIGFuZCB0aGV5IG11c3QgYmUgdGhlIHNhbWUuXG4gKlxuICogVGhpcyBzZWVtcyBsaWtlIHRoZSBiZXN0IHN0YXJ0aW5nIHBvaW50IHRvIGluY3JlbWVudGFsbHkgZXZvbHZlIHRvIGFuXG4gKiBBUEkgd2hlcmUgdGhlc2UgY2FuIHJlbGlhYmx5IGRpZmZlci5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzRcbiAqXG4gKiBAcGFyYW0ge0RlY29kZU9wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBFbmNvZGluZykgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlRnJvbUNhcERhdGE9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPWRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YSxcbmRlY29kZVByb21pc2VGcm9tQ2FwRGF0YT1kb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVFcnJvckZyb21DYXBEYXRhPWRvbnREZWNvZGVFcnJvckZyb21DYXBEYXRhfT1cbmRlY29kZU9wdGlvbnM7XG5cbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPT09ZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhfHxcbkZhaWwgYEFuIGltcGxlbWVudGF0aW9uIHJlc3RyaWN0aW9uIGZvciBub3c6IElmIGVpdGhlciBkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSBvciBkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZSBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lOiAke3EoXG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSlcbiB9IHZzICR7cShkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEpfWA7XG5cbi8qKlxuICogYGRlY29kZUZyb21DYXBEYXRhYCBtYXkgcmVseSBvbiBganNvbkVuY29kZWRgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBqc29uRW5jb2RlZGBcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvQ2FwRGF0YWBcbiAqIGFib3ZlLCBpLmUuLCBgZGVjb2RlRnJvbUNhcERhdGFgIGNhbm5vdCByZWx5IG9uIGBqc29uRW5jb2RlZGAgYmVpbmcgYVxuICogdmFsaWQgbWFyc2hhbGxlZCByZXByZXNlbnRhdGlvbi4gUmF0aGVyLCBgZGVjb2RlRnJvbUNhcERhdGFgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30ganNvbkVuY29kZWQgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tQ2FwRGF0YT0oanNvbkVuY29kZWQpPT57XG5pZighaXNPYmplY3QoanNvbkVuY29kZWQpKXtcbi8qIHByaW1pdGl2ZXMgcGFzcyB0aHJvdWdoKi9cbnJldHVybiBqc29uRW5jb2RlZDtcbiB9XG5pZihpc0FycmF5KGpzb25FbmNvZGVkKSl7XG5yZXR1cm4ganNvbkVuY29kZWQubWFwKChlbmNvZGVkVmFsKT0+ZGVjb2RlRnJvbUNhcERhdGEoZW5jb2RlZFZhbCkpO1xuIH1lbHNlIGlmKGhhc1FDbGFzcyhqc29uRW5jb2RlZCkpe1xuY29uc3QgcWNsYXNzPWpzb25FbmNvZGVkW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCAke3EoUUNMQVNTKX0gdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuc3dpdGNoKHFjbGFzcyl7XG4vKiBFbmNvZGluZyBvZiBwcmltaXRpdmVzIG5vdCBoYW5kbGVkIGJ5IEpTT04qL1xuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdOYU4nOntcbnJldHVybiBOYU47XG4gfVxuY2FzZSdJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnLUluZmluaXR5Jzp7XG5yZXR1cm4tSW5maW5pdHk7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309anNvbkVuY29kZWQ7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuIEJpZ0ludChkaWdpdHMpO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBEZXByZWNhdGVkIHFjbGFzcy4gVE9ETyBtYWtlIGNvbmRpdGlvbmFsKi9cbi8qIG9uIGVudmlyb25tZW50IHZhcmlhYmxlLiBFdmVudHVhbGx5IHJlbW92ZSwgYnV0IGFmdGVyIGNvbmZpZGVudCovXG4vKiB0aGF0IHRoZXJlIGFyZSBubyBtb3JlIHN1cHBvcnRlZCBzZW5kZXJzLiovXG4vKiovXG5yZXR1cm4gU3ltYm9sLmFzeW5jSXRlcmF0b3I7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PWpzb25FbmNvZGVkO1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PWpzb25FbmNvZGVkO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLGRlY29kZUZyb21DYXBEYXRhKHBheWxvYWQpKTtcbiB9XG5jYXNlJ3Nsb3QnOntcbi8qIFNlZSBub3RlIGFib3ZlIGFib3V0IGhvdyB0aGUgY3VycmVudCBlbmNvZGluZyBjYW5ub3QgcmVsaWFibHkqL1xuLyogZGlzdGluZ3Vpc2ggd2hpY2ggd2Ugc2hvdWxkIGNhbGwsIHNvIGluIHRoZSBub24tZGVmYXVsdCBjYXNlKi9cbi8qIGJvdGggbXVzdCBiZSB0aGUgc2FtZSBhbmQgaXQgZG9lc24ndCBtYXR0ZXIgd2hpY2ggd2UgY2FsbC4qL1xuY29uc3QgZGVjb2RlZD1kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YShcbmpzb25FbmNvZGVkLFxuZGVjb2RlRnJvbUNhcERhdGEpO1xuXG4vKiBCRVdBUkU6IGNhcGRhdGEgZG9lcyBub3QgY2hlY2sgdGhhdCBgZGVjb2RlZGAgaXMqL1xuLyogYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLCBzaW5jZSB0aGF0IHdvdWxkIGJyZWFrIHNvbWUqL1xuLyogY2FwZGF0YSBjbGllbnRzLiBXZSBhcmUgZGVwcmVjYXRpbmcgY2FwZGF0YSwgYW5kIHRoZXNlIGNsaWVudHMqL1xuLyogd2lsbCBuZWVkIHRvIHVwZGF0ZSBiZWZvcmUgc3dpdGNoaW5nIHRvIHNtYWxsY2Fwcy4qL1xucmV0dXJuIGRlY29kZWQ7XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZGVjb2RlZD1kZWNvZGVFcnJvckZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbmlmKHBhc3NTdHlsZU9mKGRlY29kZWQpPT09J2Vycm9yJyl7XG5yZXR1cm4gZGVjb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YSBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7ZGVjb2RlZH1gO1xuIH1cbmNhc2UnaGlsYmVydCc6e1xuY29uc3R7b3JpZ2luYWwscmVzdH09anNvbkVuY29kZWQ7XG5oYXNPd25Qcm9wZXJ0eU9mKGpzb25FbmNvZGVkLCdvcmlnaW5hbCcpfHxcbkZhaWwgYEludmFsaWQgSGlsYmVydCBIb3RlbCBlbmNvZGluZyAke2pzb25FbmNvZGVkfWA7XG4vKiBEb24ndCBoYXJkZW4gc2luY2Ugd2UncmUgbm90IGRvbmUgbXV0YXRpbmcgaXQqL1xuY29uc3QgcmVzdWx0PXtbUUNMQVNTXTpkZWNvZGVGcm9tQ2FwRGF0YShvcmlnaW5hbCl9O1xuaWYoaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwncmVzdCcpKXtcbmNvbnN0IGlzTm9uRW1wdHlPYmplY3Q9XG50eXBlb2YgcmVzdD09PSdvYmplY3QnJiZcbnJlc3QhPT1udWxsJiZcbm93bktleXMocmVzdCkubGVuZ3RoPj0xO1xuaWYoIWlzTm9uRW1wdHlPYmplY3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyBtdXN0IGJlIGEgbm9uLWVtcHR5IG9iamVjdDogJHtyZXN0fWA7XG4gfVxuY29uc3QgcmVzdE9iaj1kZWNvZGVGcm9tQ2FwRGF0YShyZXN0KTtcbi8qIFRPRE8gcmVhbGx5IHNob3VsZCBhc3NlcnQgdGhhdCBgcGFzc1N0eWxlT2YocmVzdClgIGlzKi9cbi8qIGAnY29weVJlY29yZCdgIGJ1dCB3ZSdkIGhhdmUgdG8gaGFyZGVuIGl0IGFuZCBpdCBpcyB0b28qL1xuLyogZWFybHkgdG8gZG8gdGhhdC4qL1xuIWhhc093blByb3BlcnR5T2YocmVzdE9iaixRQ0xBU1MpfHxcbkZhaWwgYFJlc3QgbXVzdCBub3QgY29udGFpbiBpdHMgb3duIGRlZmluaXRpb24gb2YgJHtxKFFDTEFTUyl9YDtcbmRlZmluZVByb3BlcnRpZXMocmVzdWx0LGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocmVzdE9iaikpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBUaGlzIGlzIHRoZSBlcnJvciBjYXNlIHdlJ3JlIHRlc3RpbmcgZm9yKi9cbmNhc2UnaWJpZCc6e1xudGhyb3cgRmFpbCBgVGhlIGNhcERhdGEgcHJvdG9jb2wgbm8gbG9uZ2VyIHN1cHBvcnRzICR7cShRQ0xBU1MpfSAke3EoXG5xY2xhc3MpXG4gfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2V7XG5hc3NlcnQodHlwZW9mIGpzb25FbmNvZGVkPT09J29iamVjdCcmJmpzb25FbmNvZGVkIT09bnVsbCk7XG5jb25zdCBkZWNvZGVFbnRyeT0oW25hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5ICR7cShuYW1lKX0gb2YgJHtqc29uRW5jb2RlZH0gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoanNvbkVuY29kZWQpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVGcm9tQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZURlY29kZUZyb21DYXBEYXRhKG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJRQ0xBU1MiOlsiUUNMQVNTIl0sIm1ha2VFbmNvZGVUb0NhcERhdGEiOlsibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJtYWtlRGVjb2RlRnJvbUNhcERhdGEiOlsibWFrZURlY29kZUZyb21DYXBEYXRhIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIiwibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IHBhc3NTdHlsZU9mLGlzRXJyb3JMaWtlLG1ha2VUYWdnZWQsZ2V0VGFnLGhhc093blByb3BlcnR5T2YsYXNzZXJ0UGFzc2FibGVTeW1ib2wsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZSxYLEZhaWwscTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRozY9fYSA9PiAobWFrZVRhZ2dlZCA9ICRozY9fYSldXSxbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV0sW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc2FibGUsIFJlbW90YWJsZX0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZScgKi9cbi8qIEZJWE1FIGRlZmluZSBhY3R1YWwgdHlwZXMqL1xuLyoqIEB0eXBlZGVmIHthbnl9IFNtYWxsY2Fwc0VuY29kaW5nICovXG4vKiogQHR5cGVkZWYge2FueX0gU21hbGxjYXBzRW5jb2RpbmdVbmlvbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtpcyxlbnRyaWVzLGZyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0IEJBTkc9JyEnLmNoYXJDb2RlQXQoMCk7XG5jb25zdCBEQVNIPSctJy5jaGFyQ29kZUF0KDApO1xuXG4vKipcbiAqIEFuIGBlbmNvZGVUb1NtYWxsY2Fwc2AgZnVuY3Rpb24gdGFrZXMgYSBwYXNzYWJsZSBhbmQgcmV0dXJucyBhXG4gKiBKU09OLXJlcHJlc2VudGFibGUgb2JqZWN0IChpLmUuLCByb3VuZC10cmlwcGluZyBpdCB0aHJvdWdoXG4gKiBgSlNPTi5zdHJpbmdpZnlgIGFuZCBgSlNPTi5wYXJzZWAgd2l0aCBubyByZXBsYWNlcnMgb3IgcmV2aXZlcnNcbiAqIHJldHVybnMgYW4gZXF1aXZhbGVudCBzdHJ1Y3R1cmUgZXhjZXB0IGZvciBvYmplY3QgaWRlbnRpdHkpLlxuICogV2UgY2FsbCB0aGlzIHJlcHJlc2VudGF0aW9uIGEgU21hbGxjYXBzIEVuY29kaW5nLlxuICpcbiAqIEEgYGRlY29kZUZyb21TbWFsbGNhcHNgIGZ1bmN0aW9uIHRha2VzIGFzIGFyZ3VtZW50IHdoYXQgaXRcbiAqICphc3N1bWVzKiBpcyB0aGUgcmVzdWx0IG9mIGEgcGxhaW4gYEpTT04ucGFyc2VgIHdpdGggbm8gcmVzb2x2ZXIuIEl0IHRoZW5cbiAqIG11c3QgdmFsaWRhdGUgdGhhdCBpdCBpcyBhIHZhbGlkIFNtYWxsY2FwcyBFbmNvZGluZywgYW5kIGlmIGl0IGlzLFxuICogcmV0dXJuIGEgY29ycmVzcG9uZGluZyBwYXNzYWJsZS5cbiAqXG4gKiBTbWFsbGNhcHMgY29uc2lkZXJzIHRoZSBjaGFyYWN0ZXJzIGJldHdlZW4gYCFgIChhc2NpaSBjb2RlIDMzLCBCQU5HKVxuICogYW5kIGAtYCAoYXNjaWkgY29kZSA0NSwgREFTSCkgdG8gYmUgc3BlY2lhbCBwcmVmaXhlcyBhbGxvd2luZ1xuICogcmVwcmVzZW50YXRpb24gb2YgSlNPTi1pbmNvbXBhdGlibGUgZGF0YSB1c2luZyBzdHJpbmdzLlxuICogVGhlc2UgY2hhcmFjdGVycywgaW4gb3JkZXIsIGFyZSBgIVwiIyQlJicoKSorLC1gXG4gKiBPZiB0aGVzZSwgc21hbGxjYXBzIGN1cnJlbnRseSB1c2VzIHRoZSBmb2xsb3dpbmc6XG4gKlxuICogICogYCFgIC0gZXNjYXBlZCBzdHJpbmdcbiAqICAqIGArYCAtIG5vbi1uZWdhdGl2ZSBiaWdpbnRcbiAqICAqIGAtYCAtIG5lZ2F0aXZlIGJpZ2ludFxuICogICogYCNgIC0gbWFuaWZlc3QgY29uc3RhbnRcbiAqICAqIGAlYCAtIHN5bWJvbFxuICogICogYCRgIC0gcmVtb3RhYmxlXG4gKiAgKiBgJmAgLSBwcm9taXNlXG4gKlxuICogQWxsIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycyAoYFwiJygpKixgKSBhcmUgcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuXG4gKlxuICogVGhlIG1hbmlmZXN0IGNvbnN0YW50cyB0aGF0IHNtYWxsY2FwcyBjdXJyZW50bHkgdXNlcyBmb3IgdmFsdWVzOlxuICogICogYCN1bmRlZmluZWRgXG4gKiAgKiBgI05hTmBcbiAqICAqIGAjSW5maW5pdHlgXG4gKiAgKiBgIy1JbmZpbml0eWBcbiAqXG4gKiBhbmQgZm9yIHByb3BlcnR5IG5hbWVzIGFuYWxvZ291cyB0byBjYXBkYXRhIEBxY2xhc3M6XG4gKiAgKiBgI3RhZ2BcbiAqICAqIGAjZXJyb3JgXG4gKlxuICogQWxsIG90aGVyIGVuY29kZWQgc3RyaW5ncyBiZWdpbm5pbmcgd2l0aCBgI2AgYXJlIHJlc2VydmVkIGZvclxuICogZnV0dXJlIHVzZS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFN0clxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHN0YXJ0c1NwZWNpYWw9KGVuY29kZWRTdHIpPT57XG5pZihlbmNvZGVkU3RyPT09Jycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbi8qIGNoYXJDb2RlQXQoMCkgYW5kIG51bWJlciBjb21wYXJlIGlzIGEgYml0IGZhc3Rlci4qL1xuY29uc3QgY29kZT1lbmNvZGVkU3RyLmNoYXJDb2RlQXQoMCk7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgeW9kYSovXG5yZXR1cm4gQkFORzw9Y29kZSYmY29kZTw9REFTSDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZVRvU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIHJlbW90YWJsZTogUmVtb3RhYmxlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVFcnJvclRvU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz0ocmVtKT0+XG5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtyZW19YDtcblxuY29uc3QgZG9udEVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz0ocHJvbSk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwcm9tfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIpPT5cbkZhaWwgYGVycm9yIG9iamVjdCB1bmV4cGVjdGVkOiAke3EoZXJyKX1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlVG9TbWFsbGNhcHNPcHRpb25zfSBbZW5jb2RlT3B0aW9uc11cbiAqIGVuY29kZU9wdGlvbnMgaXMgYWN0dWFsbHkgb3B0aW9uYWwsIGJ1dCBub3QgbWFya2VkIGFzIHN1Y2ggdG8gd29yayBhcm91bmRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAyODZcbiAqXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW5jb2RlVG9TbWFsbGNhcHM9KGVuY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzPWRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyxcbmVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz1kb250RW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzLFxuZW5jb2RlRXJyb3JUb1NtYWxsY2Fwcz1kb250RW5jb2RlRXJyb3JUb1NtYWxsY2Fwc309XG5lbmNvZGVPcHRpb25zO1xuXG5jb25zdCBhc3NlcnRFbmNvZGVkRXJyb3I9KGVuY29kaW5nKT0+e1xudHlwZW9mIGVuY29kaW5nPT09J29iamVjdCcmJmhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyNlcnJvcicpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGhhdmUgXCIjZXJyb3JcIiBwcm9wZXJ0eTogJHtxKFxuZW5jb2RpbmcpXG4gfWA7XG4vKiBBc3NlcnQgdGhhdCB0aGUgI2Vycm9yIHByb3BlcnR5IGRlY29kZXMgdG8gYSBzdHJpbmcuKi9cbmNvbnN0IG1lc3NhZ2U9ZW5jb2RpbmdbJyNlcnJvciddO1xudHlwZW9mIG1lc3NhZ2U9PT0nc3RyaW5nJyYmKFxuIXN0YXJ0c1NwZWNpYWwobWVzc2FnZSl8fG1lc3NhZ2UuY2hhckF0KDApPT09JyEnKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBoYXZlIHN0cmluZyBtZXNzYWdlOiAke3EobWVzc2FnZSl9YDtcbiB9O1xuXG4vKipcbiAqIE11c3QgZW5jb2RlIGB2YWxgIGludG8gcGxhaW4gSlNPTiBkYXRhICpjYW5vbmljYWxseSosIHN1Y2ggdGhhdFxuICogYEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpID09PSBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKWAuIEZvciBtb3N0XG4gKiBlbmNvZGluZ3MsIHRoZSBvcmRlciBvZiBwcm9wZXJ0aWVzIG9mIGVhY2ggbm9kZSBvZiB0aGUgb3V0cHV0XG4gKiBzdHJ1Y3R1cmUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYWxnb3JpdGhtIGJlbG93IHdpdGhvdXQgc3BlY2lhbFxuICogYXJyYW5nZW1lbnQsIHVzdWFsbHkgYnkgYmVpbmcgZXhwcmVzc2VkIGRpcmVjdGx5IGFzIGFuIG9iamVjdCBsaXRlcmFsLlxuICogVGhlIGV4Y2VwdGlvbiBpcyBjb3B5UmVjb3Jkcywgd2hvc2UgbmF0dXJhbCBlbnVtZXJhdGlvbiBvcmRlclxuICogY2FuIGRpZmZlciBiZXR3ZWVuIGNvcHlSZWNvcmRzIHRoYXQgb3VyIGRpc3RyaWJ1dGVkIG9iamVjdCBzZW1hbnRpY3NcbiAqIGNvbnNpZGVycyB0byBiZSBlcXVpdmFsZW50LlxuICogU2luY2UsIGZvciBlYWNoIGNvcHlSZWNvcmQsIHdlIG9ubHkgYWNjZXB0IHN0cmluZyBwcm9wZXJ0eSBuYW1lcyxcbiAqIG5vdCBzeW1ib2xzLCB3ZSBjYW4gY2Fub25pY2FsbHkgc29ydCB0aGUgbmFtZXMgZmlyc3QuXG4gKiBKU09OLnN0cmluZ2lmeSB3aWxsIHRoZW4gdmlzaXQgdGhlc2UgaW4gdGhhdCBzb3J0ZWQgb3JkZXIuXG4gKlxuICogRW5jb2Rpbmcgd2l0aCBhIGNhbm9uaWNhbC1KU09OIGVuY29kZXIgd291bGQgYWxzbyBzb2x2ZSB0aGlzIGNhbm9uaWNhbG5lc3NcbiAqIHByb2JsZW0gaW4gYSBtb3JlIG1vZHVsYXIgYW5kIGVuY2Fwc3VsYXRlZCBtYW5uZXIuIE5vdGUgdGhhdCB0aGVcbiAqIGFjdHVhbCBvcmRlciBwcm9kdWNlZCBoZXJlLCB0aG91Z2ggaXQgYWdyZWVzIHdpdGggY2Fub25pY2FsLUpTT04gb25cbiAqIGNvcHlSZWNvcmQgcHJvcGVydHkgb3JkZXJpbmcsIGRpZmZlcnMgZnJvbSBjYW5vbmljYWwtSlNPTiBhcyBhIHdob2xlXG4gKiBpbiB0aGF0IHRoZSBvdGhlciByZWNvcmQgcHJvcGVydGllcyBhcmUgdmlzaXRlZCBpbiB0aGUgb3JkZXIgaW4gd2hpY2hcbiAqIHRoZXkgYXJlIGxpdGVyYWxseSB3cml0dGVuIGJlbG93LiBUT0RPIHBlcmhhcHMgd2Ugc2hvdWxkIGluZGVlZCBzd2l0Y2hcbiAqIHRvIGEgY2Fub25pY2FsIEpTT04gZW5jb2RlciwgYW5kIG5vdCBkZWxpY2F0ZWx5IGRlcGVuZCBvbiB0aGUgb3JkZXJcbiAqIGluIHdoaWNoIHRoZXNlIG9iamVjdCBsaXRlcmFscyBhcmUgd3JpdHRlbi5cbiAqXG4gKiBSZWFkZXJzIG11c3Qgbm90IGNhcmUgYWJvdXQgdGhpcyBvcmRlciBhbnl3YXkuIFdlIGltcG9zZSB0aGlzIHJlcXVpcmVtZW50XG4gKiBtYWlubHkgdG8gcmVkdWNlIG5vbi1kZXRlcm1pbmlzbSBleHBvc2VkIG91dHNpZGUgYSB2YXQuXG4gKlxuICogQHBhcmFtIHthbnl9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7U21hbGxjYXBzRW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb1NtYWxsY2Fwc2AgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb1NtYWxsY2Fwc2AgaXMgbm90XG4gKiBkaXJlY3RseSBleHBvc2VkLlxuICogV2hhdCdzIGV4cG9zZWQgaW5zdGVhZCBpcyBhIHdyYXBwZXIgdGhhdCBmcmVlemVzIHRoZSBvdXRwdXQgYmVmb3JlXG4gKiByZXR1cm5pbmcuIElmIHRoaXMgdHVybnMgb3V0IHRvIGltcGVkZSBzdGF0aWMgYW5hbHlzaXMgZm9yIGBoYXJkZW5gIHNhZmV0eSxcbiAqIHdlIGNhbiBhbHdheXMgcHV0IHRoZSAobm93IHJlZHVuZGFudCkgaGFyZGVucyBiYWNrIGluLiBUaGV5IGRvbid0IGh1cnQuXG4gKi9cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgaW50byBzbWFsbGNhcHMgc3RyaW5ncy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZihzdGFydHNTcGVjaWFsKHBhc3NhYmxlKSl7XG4vKiBTdHJpbmdzIHRoYXQgc3RhcnQgd2l0aCBhIHNwZWNpYWwgY2hhciBhcmUgcXVvdGVkIHdpdGggYCFgLiovXG4vKiBTaW5jZSBgIWAgaXMgaXRzZWxmIGEgc3BlY2lhbCBjaGFyYWN0ZXIsIHRoaXMgdHJpdmlhbGx5IGRvZXMqL1xuLyogdGhlIEhpbGJlcnQgaG90ZWwuIEFsc28sIHNpbmNlIHRoZSBzcGVjaWFsIGNoYXJhY3RlcnMgYXJlKi9cbi8qIGEgY29udGludW91cyBzdWJyYW5nZSBvZiBhc2NpaSwgdGhpcyBxdW90aW5nIGlzIHNvcnQtb3JkZXIqL1xuLyogcHJlc2VydmluZy4qL1xucmV0dXJuIGAhJHtwYXNzYWJsZX1gO1xuIH1cbi8qIEFsbCBvdGhlciBzdHJpbmdzIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJyN1bmRlZmluZWQnO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybicjTmFOJztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybicjSW5maW5pdHknO1xuIH1lbHNlIGlmKHBhc3NhYmxlPT09LUluZmluaXR5KXtcbnJldHVybicjLUluZmluaXR5JztcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0IHN0cj1TdHJpbmcocGFzc2FibGUpO1xucmV0dXJuICgvKiogQHR5cGUge2JpZ2ludH0gKi9wYXNzYWJsZTwwbj9zdHI6YCske3N0cn1gKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJuIGAlJHtuYW1lfWA7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKG5hbWUpLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm57XG4nI3RhZyc6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihnZXRUYWcocGFzc2FibGUpKSxcbnBheWxvYWQ6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZS5wYXlsb2FkKX07XG5cbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyQnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuLyogYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEJ1dCBsaW50ZXIgY29uZnVzZWQqL1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIkXCI6ICR7cmVzdWx0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyYnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJlwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvclRvU21hbGxjYXBzKHBhc3NhYmxlLGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuYXNzZXJ0RW5jb2RlZEVycm9yKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9TbWFsbGNhcHM9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5jb25zdCByZXN1bHQ9aGFyZGVuKFxuZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKSk7XG5cbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwcyk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvU21hbGxjYXBzKG1ha2VFbmNvZGVUb1NtYWxsY2Fwcyk7XG5oYXJkZW4obWFrZUVuY29kZVRvU21hbGxjYXBzKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVGcm9tU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBSZW1vdGFibGV9IFtkZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRFcnJvcjogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7cShlbmNvZGluZyl9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0RlY29kZUZyb21TbWFsbGNhcHNPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogU21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZUZyb21TbWFsbGNhcHM9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9ZG9udERlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9ZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwc309XG5kZWNvZGVPcHRpb25zO1xuXG4vKipcbiAqIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBtYXkgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBlbmNvZGluZ2BcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvU21hbGxjYXBzYFxuICogYWJvdmUsIGkuZS4sIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBjYW5ub3QgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIGFcbiAqIHZhbGlkIG1hcnNoYWxsZWQgcmVwcmVzZW50YXRpb24uIFJhdGhlciwgYGRlY29kZUZyb21TbWFsbGNhcHNgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtTbWFsbGNhcHNFbmNvZGluZ30gZW5jb2RpbmcgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PntcbnN3aXRjaCh0eXBlb2YgZW5jb2Rpbmcpe1xuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzp7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY2FzZSdzdHJpbmcnOntcbmlmKCFzdGFydHNTcGVjaWFsKGVuY29kaW5nKSl7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY29uc3QgYz1lbmNvZGluZy5jaGFyQXQoMCk7XG5zd2l0Y2goYyl7XG5jYXNlJyEnOntcbi8qIHVuLWhpbGJlcnQtaWZ5IHRoZSBzdHJpbmcqL1xucmV0dXJuIGVuY29kaW5nLnNsaWNlKDEpO1xuIH1cbmNhc2UnJSc6e1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShlbmNvZGluZy5zbGljZSgxKSk7XG4gfVxuY2FzZScjJzp7XG5zd2l0Y2goZW5jb2Rpbmcpe1xuY2FzZScjdW5kZWZpbmVkJzp7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNhc2UnI05hTic6e1xucmV0dXJuIE5hTjtcbiB9XG5jYXNlJyNJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnIy1JbmZpbml0eSc6e1xucmV0dXJuLUluZmluaXR5O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGB1bmtub3duIGNvbnN0YW50IFwiJHtxKGVuY29kaW5nKX1cImAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH1cbmNhc2UnKyc6XG5jYXNlJy0nOntcbnJldHVybiBCaWdJbnQoZW5jb2RpbmcpO1xuIH1cbmNhc2UnJCc6e1xuY29uc3QgcmVzdWx0PWRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG4vKiBAdHMtaWdub3JlIFhYWCBTbWFsbENhcHNFbmNvZGluZyovXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3JlbW90YWJsZScpe1xuRmFpbCBgaW50ZXJuYWw6IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGEgcmVtb3RhYmxlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuY2FzZScmJzp7XG5jb25zdCByZXN1bHQ9ZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3Byb21pc2UnKXtcbkZhaWwgYGludGVybmFsOiBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYSBwcm9taXNlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBTcGVjaWFsIGNoYXIgJHtxKFxuYylcbiB9IHJlc2VydmVkIGZvciBmdXR1cmUgdXNlOiAke2VuY29kaW5nfWA7XG4gfX1cblxuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihlbmNvZGluZz09PW51bGwpe1xucmV0dXJuIGVuY29kaW5nO1xuIH1cblxuaWYoaXNBcnJheShlbmNvZGluZykpe1xucmV0dXJuIGVuY29kaW5nLm1hcCgodmFsKT0+ZGVjb2RlRnJvbVNtYWxsY2Fwcyh2YWwpKTtcbiB9XG5cbmlmKGhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyN0YWcnKSl7XG5jb25zdHsnI3RhZyc6dGFnLHBheWxvYWQsLi4ucmVzdH09ZW5jb2Rpbmc7XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVmFsdWUgb2YgXCIjdGFnXCIsIHRoZSB0YWcsIG11c3QgYmUgYSBzdHJpbmc6ICR7ZW5jb2Rpbmd9YDtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGAjdGFnIHJlY29yZCB1bmV4cGVjdGVkIHByb3BlcnRpZXM6ICR7cShvd25LZXlzKHJlc3QpKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQoXG5kZWNvZGVGcm9tU21hbGxjYXBzKHRhZyksXG5kZWNvZGVGcm9tU21hbGxjYXBzKHBheWxvYWQpKTtcblxuIH1cblxuaWYoaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI2Vycm9yJykpe1xuY29uc3QgcmVzdWx0PWRlY29kZUVycm9yRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbnBhc3NTdHlsZU9mKHJlc3VsdCk9PT0nZXJyb3InfHxcbkZhaWwgYGludGVybmFsOiBkZWNvZGVFcnJvckZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGFuIGVycm9yOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5cbmNvbnN0IGRlY29kZUVudHJ5PShbZW5jb2RlZE5hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgZW5jb2RlZE5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbmVuY29kZWROYW1lKVxuIH0gb2YgJHtlbmNvZGluZ30gbXVzdCBiZSBhIHN0cmluZ2A7XG5lbmNvZGVkTmFtZS5jaGFyQXQoMCkhPT0nIyd8fFxuRmFpbCBgVW5yZWNvZ25pemVkIHJlY29yZCB0eXBlICR7cShlbmNvZGVkTmFtZSl9OiAke2VuY29kaW5nfWA7XG5jb25zdCBuYW1lPWRlY29kZUZyb21TbWFsbGNhcHMoZW5jb2RlZE5hbWUpO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBEZWNvZGVkIHByb3BlcnR5IG5hbWUgJHtuYW1lfSBmcm9tICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoZW5jb2RpbmcpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogdW5yZWNvZ25pemVkIEpTT04gdHlwZW9mICR7cShcbnR5cGVvZiBlbmNvZGluZylcbiB9OiAke2VuY29kaW5nfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZUZyb21TbWFsbGNhcHMpO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbmNvZGVUb1NtYWxsY2FwcyI6WyJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiXSwibWFrZURlY29kZUZyb21TbWFsbGNhcHMiOlsibWFrZURlY29kZUZyb21TbWFsbGNhcHMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAcE6fMmEsAABhLAAAKgAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc3siaW1wb3J0cyI6WyJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vZXJyb3JzIiwiLi9lbmNvZGVUb0NhcERhdGEuanMiXSwiZXhwb3J0cyI6WyJkZWNvZGVUb0p1c3RpbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBOYXQsZ2V0RXJyb3JDb25zdHJ1Y3Rvcixpc09iamVjdCxwYXNzYWJsZVN5bWJvbEZvck5hbWUscSxYLEZhaWwsUUNMQVNTOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7RW5jb2Rpbmd9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3N0cmluZ2lmeTpxdW90ZX09SlNPTjtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbmRlbnRlclxuICogQHByb3BlcnR5IHsob3BlbkJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBvcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gbGluZVxuICogQHByb3BlcnR5IHsodG9rZW46IHN0cmluZykgPT4gbnVtYmVyfSBuZXh0XG4gKiBAcHJvcGVydHkgeyhjbG9zZUJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBjbG9zZVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGRvbmVcbiAqL1xuXG4vKipcbiAqIEdlbmVyb3VzIHdoaXRlc3BhY2UgZm9yIHJlYWRhYmlsaXR5XG4gKlxuICogQHJldHVybnMge0luZGVudGVyfVxuICovXG5jb25zdCBtYWtlWWVzSW5kZW50ZXI9KCk9PntcbmNvbnN0IHN0cmluZ3M9W107XG5sZXQgbGV2ZWw9MDtcbmxldCBuZWVkU3BhY2U9ZmFsc2U7XG5jb25zdCBsaW5lPSgpPT57XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKCdcXG4nLCcgICcucmVwZWF0KGxldmVsKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT57XG5sZXZlbCs9MTtcbmlmKG5lZWRTcGFjZSl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKG9wZW5CcmFja2V0KTtcbiB9LFxubGluZSxcbm5leHQ6KHRva2VuKT0+e1xuaWYobmVlZFNwYWNlJiZ0b2tlbiE9PScsJyl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9dHJ1ZTtcbnJldHVybiBzdHJpbmdzLnB1c2godG9rZW4pO1xuIH0sXG5jbG9zZTooY2xvc2VCcmFja2V0KT0+e1xuYXNzZXJ0KGxldmVsPj0xKTtcbmxldmVsLT0xO1xubGluZSgpO1xucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT57XG5hc3NlcnQuZXF1YWwobGV2ZWwsMCk7XG5yZXR1cm4gc3RyaW5ncy5qb2luKCcnKTtcbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIElmIHRoZSBsYXN0IGNoYXJhY3RlciBvZiBvbmUgdG9rZW4gdG9nZXRoZXIgd2l0aCB0aGUgZmlyc3QgY2hhcmFjdGVyXG4gKiBvZiB0aGUgbmV4dCB0b2tlbiBtYXRjaGVzIHRoaXMgcGF0dGVybiwgdGhlbiB0aGUgdHdvIHRva2VucyBtdXN0IGJlXG4gKiBzZXBhcmF0ZWQgYnkgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZSB0aGVpciBtZWFuaW5nLiBPdGhlcndpc2UgdGhlXG4gKiB3aGl0ZXNwYWNlIGluIHVubmVjZXNzYXJ5LlxuICpcbiAqIFRoZSBgPCFgIGFuZCBgLT5gIGNhc2VzIHByZXZlbnQgdGhlIGFjY2lkZW50YWwgZm9ybWF0aW9uIG9mIGFuXG4gKiBodG1sLWxpa2UgY29tbWVudC4gSSBkb24ndCB0aGluayB0aGUgZG91YmxlIGFuZ2xlIGJyYWNrZXRzIGFyZSBhY3R1YWxseVxuICogbmVlZGVkIGJ1dCBJIGhhdmVuJ3QgdGhvdWdodCBhYm91dCBpdCBlbm91Z2ggdG8gcmVtb3ZlIHRoZW0uXG4gKi9cbmNvbnN0IGJhZFBhaXJQYXR0ZXJuPS9eKD86XFx3XFx3fDw8fD4+fFxcK1xcK3wtLXw8IXwtPikkLztcblxuLyoqXG4gKiBNaW5pbXVtIHdoaXRlc3BhY2UgbmVlZGVkIHRvIHByZXNldmUgbWVhbmluZy5cbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VOb0luZGVudGVyPSgpPT57XG4vKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuY29uc3Qgc3RyaW5ncz1bXTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT5zdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpLFxubGluZTooKT0+c3RyaW5ncy5sZW5ndGgsXG5uZXh0Oih0b2tlbik9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xKXtcbmNvbnN0IGxhc3Q9c3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzIC0tIGVycm9yKi9cbmlmKGxhc3QubGVuZ3RoPj0xJiZ0b2tlbi5sZW5ndGg+PTEpe1xuY29uc3QgcGFpcj0gYCR7bGFzdFtsYXN0Lmxlbmd0aC0xXX0ke3Rva2VuWzBdfWA7XG5pZihiYWRQYWlyUGF0dGVybi50ZXN0KHBhaXIpKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbiB9XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5pZihzdHJpbmdzLmxlbmd0aD49MSYmc3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXT09PScsJyl7XG5zdHJpbmdzLnBvcCgpO1xuIH1cbnJldHVybiBzdHJpbmdzLnB1c2goY2xvc2VCcmFja2V0KTtcbiB9LFxuZG9uZTooKT0+c3RyaW5ncy5qb2luKCcnKX0pO1xuXG4gfTtcblxuY29uc3QgaWRlbnRQYXR0ZXJuPS9eW2EtekEtWl1cXHcqJC87XG5oYXJkZW4oaWRlbnRQYXR0ZXJuKTtcbmNvbnN0IEF0QXRQcmVmaXhQYXR0ZXJuPS9eQEAoLiopJC87XG5oYXJkZW4oQXRBdFByZWZpeFBhdHRlcm4pO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kaW5nXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBzaG91bGRJbmRlbnRcbiAqIEBwYXJhbSB7YW55W119IFtzbG90c11cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGRlY29kZVRvSnVzdGluPShlbmNvZGluZyxzaG91bGRJbmRlbnQ9ZmFsc2Usc2xvdHM9W10pPT57XG4vKipcbiAqIFRoZSBmaXJzdCBwYXNzIGRvZXMgc29tZSBpbnB1dCB2YWxpZGF0aW9uLlxuICogSXRzIGNvbnRyb2wgZmxvdyBzaG91bGQgbWlycm9yIGByZWN1cmAgYXMgY2xvc2VseSBhcyBwb3NzaWJsZVxuICogYW5kIHRoZSB0d28gc2hvdWxkIGJlIG1haW50YWluZWQgdG9nZXRoZXIuIFRoZXkgbXVzdCB2aXNpdCBldmVyeXRoaW5nXG4gKiBpbiB0aGUgc2FtZSBvcmRlci5cbiAqXG4gKiBUT0RPIG5vdyB0aGF0IGliaWRzIGFyZSBnb25lLCB3ZSBzaG91bGQgZm9sZCB0aGlzIGJhY2sgdG9nZXRoZXIgaW50b1xuICogb25lIHZhbGlkYXRpbmcgcGFzcy5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgcHJlcGFyZT0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG5yZXR1cm47XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBxY2xhc3MgdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG5yZXR1cm47XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbnJldHVybjtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKHRhZywnc3RyaW5nJyk7XG5wcmVwYXJlKHBheWxvYWQpO1xucmV0dXJuO1xuIH1cbmNhc2Unc2xvdCc6e1xuY29uc3R7aW5kZXgsaWZhY2V9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbk5hdChpbmRleCk7XG5pZihpZmFjZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKGlmYWNlLCdzdHJpbmcnKTtcbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xuJ29yaWdpbmFsJ2luIHJhd1RyZWV8fFxuRmFpbCBgSW52YWxpZCBIaWxiZXJ0IEhvdGVsIGVuY29kaW5nICR7cmF3VHJlZX1gO1xucHJlcGFyZShvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmlmKHR5cGVvZiByZXN0IT09J29iamVjdCcpe1xudGhyb3cgRmFpbCBgUmVzdCAke3Jlc3R9IGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0YDtcbiB9XG5pZihyZXN0PT09bnVsbCl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgbnVsbGA7XG4gfVxuaWYoaXNBcnJheShyZXN0KSl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgYW4gYXJyYXlgO1xuIH1cbmlmKFFDTEFTUyBpbiByZXN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgJHtyZXN0fSBtdXN0IG5vdCBjb250YWluICR7cShRQ0xBU1MpfWA7XG4gfVxuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbnR5cGVvZiBuYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG5wcmVwYXJlKHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgbmFtZSl9YDtcbiB9XG5nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpIT09dW5kZWZpbmVkfHxcbkZhaWwgYE11c3QgYmUgdGhlIG5hbWUgb2YgYW4gRXJyb3IgY29uc3RydWN0b3IgJHtuYW1lfWA7XG50eXBlb2YgbWVzc2FnZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbWVzc2FnZSB0eXBlb2YgJHtxKHR5cGVvZiBtZXNzYWdlKX1gO1xucmV0dXJuO1xuIH1cblxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbnByZXBhcmUocmF3VHJlZVtpXSk7XG4gfVxuIH1lbHNle1xuY29uc3QgbmFtZXM9b3duS2V5cyhyYXdUcmVlKTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbmlmKHR5cGVvZiBuYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG4gfVxucHJlcGFyZShyYXdUcmVlW25hbWVdKTtcbiB9XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VJbmRlbnRlcj1zaG91bGRJbmRlbnQ/bWFrZVllc0luZGVudGVyOm1ha2VOb0luZGVudGVyO1xubGV0IG91dD1tYWtlSW5kZW50ZXIoKTtcblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBzZWNvbmQgcGFzcyByZWN1cnNpb24gYWZ0ZXIgdGhlIGZpcnN0IHBhc3MgYHByZXBhcmVgLlxuICogVGhlIGZpcnN0IHBhc3MgZGlkIHNvbWUgaW5wdXQgdmFsaWRhdGlvbiBzb1xuICogaGVyZSB3ZSBjYW4gc2FmZWx5IGFzc3VtZSBldmVyeXRoaW5nIHRob3NlIHRoaW5ncyBhcmUgdmFsaWRhdGVkLlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHtudW1iZXJ9XG4gKi9cbmNvbnN0IGRlY29kZT0ocmF3VHJlZSk9Pntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gcmVjdXIocmF3VHJlZSk7XG4gfTtcblxuY29uc3QgZGVjb2RlUHJvcGVydHk9KG5hbWUsdmFsdWUpPT57XG5vdXQubGluZSgpO1xuaWYobmFtZT09PSdfX3Byb3RvX18nKXtcbi8qIEphdmFTY3JpcHQgaW50ZXJwcmV0cyBge19fcHJvdG9fXzogeCwgLi4ufWAqL1xuLyogYXMgbWFraW5nIGFuIG9iamVjdCBpbmhlcml0aW5nIGZyb20gYHhgLCB3aGVyZWFzKi9cbi8qIGluIEpTT04gaXQgaXMgc2ltcGx5IGEgcHJvcGVydHkgbmFtZS4gUHJlc2VydmUgdGhlKi9cbi8qIEpTT04gbWVhbmluZy4qL1xub3V0Lm5leHQoIGBbXCJfX3Byb3RvX19cIl06YCk7XG4gfWVsc2UgaWYoaWRlbnRQYXR0ZXJuLnRlc3QobmFtZSkpe1xub3V0Lm5leHQoIGAke25hbWV9OmApO1xuIH1lbHNle1xub3V0Lm5leHQoIGAke3F1b3RlKG5hbWUpfTpgKTtcbiB9XG5kZWNvZGUodmFsdWUpO1xub3V0Lm5leHQoJywnKTtcbiB9O1xuXG4vKipcbiAqIE1vZGVsZWQgYWZ0ZXIgYGZ1bGxSZXZpdmVgIGluIG1hcnNoYWwuanNcbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCByZWN1cj0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG4vKiBwcmltaXRpdmVzIGdldCBxdW90ZWQqL1xucmV0dXJuIG91dC5uZXh0KHF1b3RlKHJhd1RyZWUpKTtcbiB9XG4vKiBBc3NlcnRpb25zIG9mIHRoZSBhYm92ZSB0byBuYXJyb3cgdGhlIHR5cGUuKi9cbmFzc2VydC50eXBlb2YocmF3VHJlZSwnb2JqZWN0Jyk7XG5hc3NlcnQocmF3VHJlZSE9PW51bGwpO1xuaWYoUUNMQVNTIGluIHJhd1RyZWUpe1xuY29uc3QgcWNsYXNzPXJhd1RyZWVbUUNMQVNTXTtcbmFzc2VydC50eXBlb2YocWNsYXNzLCdzdHJpbmcnKTtcbmFzc2VydCghaXNBcnJheShyYXdUcmVlKSk7XG4vKiBTd2l0Y2hpbmcgb24gYGVuY29kZWRbUUNMQVNTXWAgKG9yIGFueXRoaW5nIGxlc3MgZGlyZWN0LCBsaWtlKi9cbi8qIGBxY2xhc3NgKSBkb2VzIG5vdCBkaXNjcmltaW5hdGUgcmF3VHJlZSBpbiB0eXBlc2NyaXB0QDQuMi4zIGFuZCovXG4vKiBlYXJsaWVyLiovXG5zd2l0Y2gocmF3VHJlZVsnQHFjbGFzcyddKXtcbi8qIEVuY29kaW5nIG9mIHByaW1pdGl2ZXMgbm90IGhhbmRsZWQgYnkgSlNPTiovXG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ05hTic6XG5jYXNlJ0luZmluaXR5JzpcbmNhc2UnLUluZmluaXR5Jzp7XG4vKiBUaGVpciBxY2xhc3MgaXMgdGhlaXIgZXhwcmVzc2lvbiBzb3VyY2UuKi9cbnJldHVybiBvdXQubmV4dChxY2xhc3MpO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGRpZ2l0cywnc3RyaW5nJyk7XG5yZXR1cm4gb3V0Lm5leHQoIGAke0JpZ0ludChkaWdpdHMpfW5gKTtcbiB9XG5jYXNlJ0BAYXN5bmNJdGVyYXRvcic6e1xuLyogVE9ETyBkZXByZWNhdGVkLiBFdmVudHVhbGx5IHJlbW92ZS4qL1xucmV0dXJuIG91dC5uZXh0KCdTeW1ib2wuYXN5bmNJdGVyYXRvcicpO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5jb25zdHtuYW1lfT1yYXdUcmVlO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbmNvbnN0IHN5bT1wYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG5hc3NlcnQudHlwZW9mKHN5bSwnc3ltYm9sJyk7XG5jb25zdCByZWdpc3RlcmVkTmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihyZWdpc3RlcmVkTmFtZT09PXVuZGVmaW5lZCl7XG5jb25zdCBtYXRjaD1BdEF0UHJlZml4UGF0dGVybi5leGVjKG5hbWUpO1xuYXNzZXJ0KG1hdGNoIT09bnVsbCk7XG5jb25zdCBzdWZmaXg9bWF0Y2hbMV07XG5hc3NlcnQoU3ltYm9sW3N1ZmZpeF09PT1zeW0pO1xuYXNzZXJ0KGlkZW50UGF0dGVybi50ZXN0KHN1ZmZpeCkpO1xucmV0dXJuIG91dC5uZXh0KCBgU3ltYm9sLiR7c3VmZml4fWApO1xuIH1cbnJldHVybiBvdXQubmV4dCggYFN5bWJvbC5mb3IoJHtxdW90ZShyZWdpc3RlcmVkTmFtZSl9KWApO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdHt0YWcscGF5bG9hZH09cmF3VHJlZTtcbm91dC5uZXh0KCBgbWFrZVRhZ2dlZCgke3F1b3RlKHRhZyl9LGApO1xuZGVjb2RlKHBheWxvYWQpO1xucmV0dXJuIG91dC5uZXh0KCcpJyk7XG4gfVxuXG5jYXNlJ3Nsb3QnOntcbmxldHtpZmFjZX09cmF3VHJlZTtcbmNvbnN0IGluZGV4PU51bWJlcihOYXQocmF3VHJlZS5pbmRleCkpO1xuY29uc3QgbmVzdGVkUmVuZGVyPShhcmcpPT57XG5jb25zdCBvbGRPdXQ9b3V0O1xudHJ5e1xub3V0PW1ha2VOb0luZGVudGVyKCk7XG5kZWNvZGUoYXJnKTtcbnJldHVybiBvdXQuZG9uZSgpO1xuIH1maW5hbGx5e1xub3V0PW9sZE91dDtcbiB9XG4gfTtcbmlmKGluZGV4PHNsb3RzLmxlbmd0aCl7XG5jb25zdCBzbG90PW5lc3RlZFJlbmRlcihzbG90c1tpbmRleF0pO1xuaWYoaWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdFRvVmFsKCR7c2xvdH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3RUb1ZhbCgke3Nsb3R9LCR7aWZhY2V9KWApO1xuIH1lbHNlIGlmKGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0sJHtpZmFjZX0pYCk7XG4gfVxuXG5jYXNlJ2hpbGJlcnQnOntcbmNvbnN0e29yaWdpbmFsLHJlc3R9PXJhd1RyZWU7XG5vdXQub3BlbigneycpO1xuZGVjb2RlUHJvcGVydHkoUUNMQVNTLG9yaWdpbmFsKTtcbmlmKCdyZXN0J2luIHJhd1RyZWUpe1xuYXNzZXJ0LnR5cGVvZihyZXN0LCdvYmplY3QnKTtcbmFzc2VydChyZXN0IT09bnVsbCk7XG5jb25zdCBuYW1lcz1vd25LZXlzKHJlc3QpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbm5hbWUpXG4gfSBvZiAke3Jlc3R9IG11c3QgYmUgYSBzdHJpbmdgO1xuIH1cbmRlY29kZVByb3BlcnR5KG5hbWUscmVzdFtuYW1lXSk7XG4gfVxuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG5cbmNhc2UnZXJyb3InOntcbmNvbnN0e1xubmFtZSxcbm1lc3NhZ2UsXG5jYXVzZT11bmRlZmluZWQsXG5lcnJvcnM9dW5kZWZpbmVkfT1cbnJhd1RyZWU7XG5jYXVzZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBjYXVzZSBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbm5hbWUhPT0gYEFnZ3JlZ2F0ZUVycm9yYHx8XG5GYWlsIGBBZ2dyZWdhdGVFcnJvciBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbmVycm9ycz09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBlcnJvcnMgbm90IHlldCBpbXBsZW1lbnRlZCBpbiBtYXJzaGFsLWp1c3RpbmA7XG5yZXR1cm4gb3V0Lm5leHQoIGAke25hbWV9KCR7cXVvdGUobWVzc2FnZSl9KWApO1xuIH1cblxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgnW10nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCdbJyk7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbm91dC5saW5lKCk7XG5kZWNvZGUocmF3VHJlZVtpXSk7XG5vdXQubmV4dCgnLCcpO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ10nKTtcbiB9XG4gfWVsc2V7XG4vKiByYXdUcmVlIGlzIGFuIGBFbmNvZGluZ1JlY29yZGAgd2hpY2ggb25seSBoYXMgc3RyaW5nIGtleXMsKi9cbi8qIGJ1dCBzaW5jZSBvd25LZXlzIGlzIG5vdCBnZW5lcmljLCBpdCBjYW4ndCBwcm9wYWdhdGUgdGhhdCovXG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmF3VHJlZSk7XG5pZihuYW1lcy5sZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgne30nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCd7Jyk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJhd1RyZWVbbmFtZV0pO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG4gfVxuIH07XG5wcmVwYXJlKGVuY29kaW5nKTtcbmRlY29kZShlbmNvZGluZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9OyRozY9fb25jZS5kZWNvZGVUb0p1c3RpbihkZWNvZGVUb0p1c3Rpbik7XG5oYXJkZW4oZGVjb2RlVG9KdXN0aW4pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVjb2RlVG9KdXN0aW4iOlsiZGVjb2RlVG9KdXN0aW4iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL21hcnNoYWwuanMiXSwiZXhwb3J0cyI6WyJwYXJzZSIsInN0cmluZ2lmeSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLG1ha2VNYXJzaGFsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL21hcnNoYWwuanNcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaM2PX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEBpbXBvcnQge1Bhc3NhYmxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFZhbFRvU2xvdD0odmFsKT0+XG5GYWlsIGBNYXJzaGFsJ3Mgc3RyaW5naWZ5IHJlamVjdHMgcHJlc2VuY2VzIGFuZCBwcm9taXNlcyAke3ZhbH1gO1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFNsb3RUb1ZhbD0oc2xvdCxfaWZhY2UpPT5cbkZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3RzICR7c2xvdH1gO1xuXG5jb25zdCBiYWRBcnJheUhhbmRsZXI9aGFyZGVuKHtcbmdldDooX3RhcmdldCxuYW1lLF9yZWNlaXZlcik9PntcbmlmKG5hbWU9PT0nbGVuZ3RoJyl7XG5yZXR1cm4gMDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBNYXJzaGFsJ3MgcGFyc2UgbXVzdCBub3QgZW5jb2RlIGFueSBzbG90IHBvc2l0aW9ucyAke25hbWV9YDtcbiB9fSk7XG5cblxuY29uc3QgYmFkQXJyYXk9aGFyZGVuKG5ldyBQcm94eShoYXJkZW4oW10pLGJhZEFycmF5SGFuZGxlcikpO1xuXG5jb25zdHtzZXJpYWxpemUsdW5zZXJpYWxpemV9PW1ha2VNYXJzaGFsKFxuZG9Ob3RDb252ZXJ0VmFsVG9TbG90LFxuZG9Ob3RDb252ZXJ0U2xvdFRvVmFsLFxue1xuZXJyb3JUYWdnaW5nOidvZmYnLFxuLyogVE9ETyBmaXggdGVzdHMgdG8gd29ya3Mgd2l0aCBzbWFsbGNhcHMuKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J2NhcGRhdGEnfSk7XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3Qgc3RyaW5naWZ5PSh2YWwpPT5zZXJpYWxpemUodmFsKS5ib2R5OyRozY9fb25jZS5zdHJpbmdpZnkoc3RyaW5naWZ5KTtcbmhhcmRlbihzdHJpbmdpZnkpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJcbiAqIEByZXR1cm5zIHt1bmtub3dufVxuICovXG5jb25zdCBwYXJzZT0oc3RyKT0+XG51bnNlcmlhbGl6ZShcbmhhcmRlbih7XG5ib2R5OnN0cixcbnNsb3RzOmJhZEFycmF5fSkpOyRozY9fb25jZS5wYXJzZShwYXJzZSk7XG5cblxuaGFyZGVuKHBhcnNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0cmluZ2lmeSI6WyJzdHJpbmdpZnkiXSwicGFyc2UiOlsicGFyc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAE7Fc3pk3AACZNwAAIwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzeyJpbXBvcnRzIjpbIkBlbmRvL25hdCIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9lcnJvcnMiLCJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyIsIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9lbmNvZGVUb1NtYWxsY2Fwcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VNYXJzaGFsIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IE5hdCxhc3NlcnRQYXNzYWJsZSxnZXRJbnRlcmZhY2VPZixnZXRFcnJvckNvbnN0cnVjdG9yLGhhc093blByb3BlcnR5T2YsdG9QYXNzYWJsZUVycm9yLFgsRmFpbCxxLG1ha2VFcnJvcixhbm5vdGF0ZUVycm9yLG9iamVjdE1hcCxRQ0xBU1MsbWFrZUVuY29kZVRvQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbUNhcERhdGEsbWFrZURlY29kZUZyb21TbWFsbGNhcHMsbWFrZUVuY29kZVRvU21hbGxjYXBzOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaM2PX2EpXV0sW1wiZ2V0SW50ZXJmYWNlT2ZcIiwgWyRozY9fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJ0b1Bhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAodG9QYXNzYWJsZUVycm9yID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJtYWtlRXJyb3JcIiwgWyRozY9fYSA9PiAobWFrZUVycm9yID0gJGjNj19hKV1dLFtcImFubm90YXRlRXJyb3JcIiwgWyRozY9fYSA9PiAoYW5ub3RhdGVFcnJvciA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2NvbW1vbi9vYmplY3QtbWFwLmpzXCIsIFtbXCJvYmplY3RNYXBcIiwgWyRozY9fYSA9PiAob2JqZWN0TWFwID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV0sW1wibWFrZUVuY29kZVRvQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRW5jb2RlVG9DYXBEYXRhID0gJGjNj19hKV1dLFtcIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbUNhcERhdGEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVRvU21hbGxjYXBzLmpzXCIsIFtbXCJtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwc1wiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyA9ICRozY9fYSldXSxbXCJtYWtlRW5jb2RlVG9TbWFsbGNhcHNcIiwgWyRozY9fYSA9PiAobWFrZUVuY29kZVRvU21hbGxjYXBzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDb252ZXJ0U2xvdFRvVmFsLCBDb252ZXJ0VmFsVG9TbG90LCBGcm9tQ2FwRGF0YSwgTWFrZU1hcnNoYWxPcHRpb25zLCBUb0NhcERhdGF9IGZyb20gJy4vdHlwZXMuanMnO1xuICogQGltcG9ydCB7UGFzc2FibGUsIFBhc3NhYmxlQ2FwLCBSZW1vdGFibGVPYmplY3R9IGZyb20gJ0BlbmRvL3Bhc3Mtc3R5bGUnO1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlY30gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSc7XG4gKiBAaW1wb3J0IHtFbmNvZGluZ30gZnJvbSAnLi90eXBlcy5qcyc7XG4gKi9cblxuY29uc3R7ZGVmaW5lUHJvcGVydGllc309T2JqZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge0NvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRWYWxUb1Nsb3RGbj0oeCk9Png7XG4vKiogQHR5cGUge0NvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRTbG90VG9WYWxGbj0oeCxfKT0+eDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgU2xvdFxuICogQHBhcmFtIHtDb252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBbY29udmVydFZhbFRvU2xvdF1cbiAqIEBwYXJhbSB7Q29udmVydFNsb3RUb1ZhbDxTbG90Pn0gW2NvbnZlcnRTbG90VG9WYWxdXG4gKiBAcGFyYW0ge01ha2VNYXJzaGFsT3B0aW9uc30gb3B0aW9uc1xuICovXG5jb25zdCAgICAgICAgbWFrZU1hcnNoYWw9KFxuY29udmVydFZhbFRvU2xvdD1kZWZhdWx0VmFsVG9TbG90Rm4sXG5jb252ZXJ0U2xvdFRvVmFsPWRlZmF1bHRTbG90VG9WYWxGbixcbntcbmVycm9yVGFnZ2luZz0nb24nLFxubWFyc2hhbE5hbWU9J2Fub24tbWFyc2hhbCcsXG4vKiBUT0RPIFRlbXBvcmFyeSBoYWNrLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8yNzgwKi9cbmVycm9ySWROdW09MTAwMDAsXG4vKiBXZSBwcmVmZXIgdGhhdCB0aGUgY2FsbGVyIGluc3RlYWQgbG9nIHRvIHNvbWV3aGVyZSBoaWRkZW4qL1xuLyogdG8gYmUgcmV2ZWFsZWQgd2hlbiBjb3JyZWxhdGluZyB3aXRoIHRoZSByZWNlaXZlZCBlcnJvci4qL1xubWFyc2hhbFNhdmVFcnJvcj0oZXJyKT0+XG5jb25zb2xlLmxvZygnVGVtcG9yYXJ5IGxvZ2dpbmcgb2Ygc2VudCBlcnJvcicsZXJyKSxcbi8qIERlZmF1bHQgdG8gJ2NhcGRhdGEnIGJlY2F1c2UgaXQgd2FzIGltcGxlbWVudGVkIGZpcnN0LiovXG4vKiBTb21ldGltZXMsIG9udG9nZW55IGRvZXMgcmVjYXBpdHVsYXRlIHBoeWxvZ2VueSA7KSovXG5zZXJpYWxpemVCb2R5Rm9ybWF0PSdjYXBkYXRhJ309XG57fSk9Plxue1xuYXNzZXJ0LnR5cGVvZihtYXJzaGFsTmFtZSwnc3RyaW5nJyk7XG5lcnJvclRhZ2dpbmc9PT0nb24nfHxcbmVycm9yVGFnZ2luZz09PSdvZmYnfHxcbkZhaWwgYFRoZSBlcnJvclRhZ2dpbmcgb3B0aW9uIGNhbiBvbmx5IGJlIFwib25cIiBvciBcIm9mZlwiICR7ZXJyb3JUYWdnaW5nfWA7XG5jb25zdCBuZXh0RXJyb3JJZD0oKT0+e1xuZXJyb3JJZE51bSs9MTtcbnJldHVybiBgZXJyb3I6JHttYXJzaGFsTmFtZX0jJHtlcnJvcklkTnVtfWA7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7VG9DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCB0b0NhcERhdGE9KHJvb3QpPT57XG5jb25zdCBzbG90cz1bXTtcbi8qIG1hcHMgdmFsIChwcm9taXNlIG9yIHJlbW90YWJsZSkgdG8gaW5kZXggb2Ygc2xvdHNbXSovXG5jb25zdCBzbG90TWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHJldHVybnMge3tpbmRleDogbnVtYmVyLCByZXBlYXQ6IGJvb2xlYW59fVxuICovXG5jb25zdCBlbmNvZGVTbG90Q29tbW9uPShwYXNzYWJsZSk9PntcbmxldCBpbmRleD1zbG90TWFwLmdldChwYXNzYWJsZSk7XG5pZihpbmRleCE9PXVuZGVmaW5lZCl7XG4vKiBUT0RPIGFzc2VydCB0aGF0IGl0J3MgdGhlIHNhbWUgaWZhY2UgYXMgYmVmb3JlKi9cbmFzc2VydC50eXBlb2YoaW5kZXgsJ251bWJlcicpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OnRydWV9KTtcbiB9XG5cbmluZGV4PXNsb3RzLmxlbmd0aDtcbmNvbnN0IHNsb3Q9Y29udmVydFZhbFRvU2xvdChwYXNzYWJsZSk7XG5zbG90cy5wdXNoKHNsb3QpO1xuc2xvdE1hcC5zZXQocGFzc2FibGUsaW5kZXgpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OmZhbHNlfSk7XG4gfTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiB1bmtub3dufSBlbmNvZGVSZWN1clxuICogQHJldHVybnMge3tlcnJvcklkPzogc3RyaW5nLCBtZXNzYWdlOiBzdHJpbmcsIG5hbWU6IHN0cmluZ319XG4gKi9cbmNvbnN0IGVuY29kZUVycm9yQ29tbW9uPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBtZXNzYWdlPWVuY29kZVJlY3VyKCBgJHtlcnIubWVzc2FnZX1gKTtcbmFzc2VydC50eXBlb2YobWVzc2FnZSwnc3RyaW5nJyk7XG5jb25zdCBuYW1lPWVuY29kZVJlY3VyKCBgJHtlcnIubmFtZX1gKTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG4vKiBUT0RPIE11c3QgZW5jb2RlIGBjYXVzZWAsIGBlcnJvcnNgLCBidXQqL1xuLyogb25seSBvbmNlIGFsbCBwb3NzaWJsZSBjb3VudGVycGFydHkgZGVjb2RlcnMgYXJlIHRvbGVyYW50IG9mKi9cbi8qIHJlY2VpdmluZyB0aGVtLiovXG5pZihlcnJvclRhZ2dpbmc9PT0nb24nKXtcbi8qIFdlIGRlbGliZXJhdGVseSBkbyBub3Qgc2hhcmUgdGhlIHN0YWNrLCBidXQgaXQgd291bGQqL1xuLyogYmUgdXNlZnVsIHRvIGxvZyB0aGUgc3RhY2sgbG9jYWxseSBzbyBzb21lb25lIHdobyBoYXMqL1xuLyogcHJpdmlsZWdlZCBhY2Nlc3MgdG8gdGhlIHRocm93aW5nIFZhdCBjYW4gY29ycmVsYXRlKi9cbi8qIHRoZSBwcm9ibGVtIHdpdGggdGhlIHJlbW90ZSBWYXQgdGhhdCBnZXRzIHRoaXMqL1xuLyogc3VtbWFyeS4gSWYgd2UgZG8gdGhhdCwgd2UgY291bGQgYWxsb2NhdGUgc29tZSByYW5kb20qL1xuLyogaWRlbnRpZmllciBhbmQgaW5jbHVkZSBpdCBpbiB0aGUgbWVzc2FnZSwgdG8gaGVscCovXG4vKiB3aXRoIHRoZSBjb3JyZWxhdGlvbi4qL1xuY29uc3QgZXJyb3JJZD1lbmNvZGVSZWN1cihuZXh0RXJyb3JJZCgpKTtcbmFzc2VydC50eXBlb2YoZXJyb3JJZCwnc3RyaW5nJyk7XG5hbm5vdGF0ZUVycm9yKGVycixYIGBTZW50IGFzICR7ZXJyb3JJZH1gKTtcbm1hcnNoYWxTYXZlRXJyb3IoZXJyKTtcbnJldHVybiBoYXJkZW4oe2Vycm9ySWQsbWVzc2FnZSxuYW1lfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHttZXNzYWdlLG5hbWV9KTtcbiB9XG4gfTtcblxuaWYoc2VyaWFsaXplQm9keUZvcm1hdD09PSdjYXBkYXRhJyl7XG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVDYXB9IHBhc3NhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV1cbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlU2xvdFRvQ2FwRGF0YT0ocGFzc2FibGUsaWZhY2U9dW5kZWZpbmVkKT0+e1xuY29uc3R7aW5kZXgscmVwZWF0fT1lbmNvZGVTbG90Q29tbW9uKHBhc3NhYmxlKTtcblxuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J3Nsb3QnLGluZGV4fSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtbUUNMQVNTXTonc2xvdCcsaWZhY2UsaW5kZXh9KTtcbiB9XG4gfTtcblxuLyoqIEB0eXBlIHsocHJvbWlzZTogUmVtb3RhYmxlT2JqZWN0LCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHZhbCxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb0NhcERhdGEodmFsLGdldEludGVyZmFjZU9mKHZhbCkpO1xuXG4vKiogQHR5cGUgeyhwcm9taXNlOiBQcm9taXNlLCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9taXNlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YShwcm9taXNlKTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ30gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidlcnJvcicsLi4uZXJyRGF0YX0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvQ2FwRGF0YT1tYWtlRW5jb2RlVG9DYXBEYXRhKHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IGVuY29kZWQ9ZW5jb2RlVG9DYXBEYXRhKHJvb3QpO1xuY29uc3QgYm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuYm9keSxcbnNsb3RzfSk7XG5cbiB9ZWxzZSBpZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J3NtYWxsY2Fwcycpe1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcHJlZml4XG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9TbWFsbGNhcHM9KHByZWZpeCxwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG4vKiBUT0RPIGV4cGxvcmUgcmVtb3ZpbmcgdGhpcyBzcGVjaWFsIGNhc2UqL1xuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fWA7XG4gfVxucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fS4ke2lmYWNlfWA7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbW90YWJsZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJCcscmVtb3RhYmxlLGdldEludGVyZmFjZU9mKHJlbW90YWJsZSkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9TbWFsbGNhcHMoJyYnLHByb21pc2UpO1xuXG5jb25zdCBlbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBlcnJEYXRhPWVuY29kZUVycm9yQ29tbW9uKGVycixlbmNvZGVSZWN1cik7XG5jb25zdHttZXNzYWdlLC4uLnJlc3R9PWVyckRhdGE7XG5yZXR1cm4gaGFyZGVuKHsnI2Vycm9yJzptZXNzYWdlLC4uLnJlc3R9KTtcbiB9O1xuXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwcz1tYWtlRW5jb2RlVG9TbWFsbGNhcHMoe1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb1NtYWxsY2Fwcyhyb290KTtcbmNvbnN0IHNtYWxsY2Fwc0JvZHk9SlNPTi5zdHJpbmdpZnkoZW5jb2RlZCk7XG5yZXR1cm4gaGFyZGVuKHtcbi8qIFZhbGlkIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYSB2YWxpZCBzaWduYWwqL1xuLyogaW5kaWNhdGluZyBzbWFsbGNhcHMgZm9ybWF0LiovXG5ib2R5OiBgIyR7c21hbGxjYXBzQm9keX1gLFxuc2xvdHN9KTtcblxuIH1lbHNle1xuLyogVGhlIGB0aHJvd2AgaXMgYSBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEFkZGVkIGZvciBjb25mdXNlZCBsaW50ZXJzLiovXG50aHJvdyBGYWlsIGBVbnJlY29nbml6ZWQgc2VyaWFsaXplQm9keUZvcm1hdDogJHtxKHNlcmlhbGl6ZUJvZHlGb3JtYXQpfWA7XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VGdWxsUmV2aXZlPShzbG90cyk9Pntcbi8qKiBAdHlwZSB7TWFwPG51bWJlciwgUmVtb3RhYmxlT2JqZWN0IHwgUHJvbWlzZT59ICovXG5jb25zdCB2YWxNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7e2lmYWNlPzogc3RyaW5nLCBpbmRleDogbnVtYmVyfX0gc2xvdERhdGFcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5jb25zdCBkZWNvZGVTbG90Q29tbW9uPShzbG90RGF0YSk9PntcbmNvbnN0e2lmYWNlPXVuZGVmaW5lZCxpbmRleCwuLi5yZXN0fT1zbG90RGF0YTtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgc2xvdCBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuY29uc3QgZXh0YW50PXZhbE1hcC5nZXQoaW5kZXgpO1xuaWYoZXh0YW50KXtcbnJldHVybiBleHRhbnQ7XG4gfVxuLyogVE9ETyBTRUNVUklUWSBIQVpBUkQ6IG11c3QgZW5mb2NlIHRoYXQgcmVtb3RhYmxlIHZzIHByb21pc2UqL1xuLyogaXMgYWNjb3JkaW5nIHRvIHRoZSBlbmNvZGVkIHN0cmluZy4qL1xuY29uc3Qgc2xvdD1zbG90c1tOdW1iZXIoTmF0KGluZGV4KSldO1xuY29uc3QgdmFsPWNvbnZlcnRTbG90VG9WYWwoc2xvdCxpZmFjZSk7XG52YWxNYXAuc2V0KGluZGV4LHZhbCk7XG5yZXR1cm4gdmFsO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHt7XG4gKiAgIGVycm9ySWQ/OiBzdHJpbmcsXG4gKiAgIG1lc3NhZ2U6IHN0cmluZyxcbiAqICAgbmFtZTogc3RyaW5nLFxuICogICBjYXVzZTogdW5rbm93bixcbiAqICAgZXJyb3JzOiB1bmtub3duLFxuICogfX0gZXJyRGF0YVxuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IGRlY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0IGRlY29kZUVycm9yQ29tbW9uPShlcnJEYXRhLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7XG5lcnJvcklkPXVuZGVmaW5lZCxcbm1lc3NhZ2UsXG5uYW1lLFxuY2F1c2U9dW5kZWZpbmVkLFxuZXJyb3JzPXVuZGVmaW5lZCxcbi4uLnJlc3R9PVxuZXJyRGF0YTtcbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8yMDUyKi9cbi8qIGNhcERhdGEgZG9lcyBub3QgdHJhbnNmb3JtIHN0cmluZ3MuIFRoZSBpbW1lZGlhdGVseSBmb2xsb3dpbmcgY2FsbHMqL1xuLyogdG8gYGRlY29kZVJlY3VyYCBhcmUgZm9yIHJldXNlIGJ5IG90aGVyIGVuY29kaW5ncyB0aGF0IGRvLCovXG4vKiBzdWNoIGFzIHNtYWxsY2Fwcy4qL1xuY29uc3QgZE5hbWU9ZGVjb2RlUmVjdXIobmFtZSk7XG5jb25zdCBkTWVzc2FnZT1kZWNvZGVSZWN1cihtZXNzYWdlKTtcbi8qIGVycm9ySWQgaXMgYSBsYXRlIGFkZGl0aW9uIHNvIGJlIHRvbGVyYW50IG9mIGl0cyBhYnNlbmNlLiovXG5jb25zdCBkRXJyb3JJZD0vKiogQHR5cGUge3N0cmluZ30gKi9lcnJvcklkJiZkZWNvZGVSZWN1cihlcnJvcklkKTtcbmlmKHR5cGVvZiBkTmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBkTmFtZSl9YDtcbiB9XG5pZih0eXBlb2YgZE1lc3NhZ2UhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgZE1lc3NhZ2UpfWA7XG4gfVxuY29uc3QgZXJyQ29uc3RydWN0b3I9Z2V0RXJyb3JDb25zdHJ1Y3RvcihkTmFtZSl8fEVycm9yO1xuY29uc3QgZXJyb3JOYW1lPVxuZEVycm9ySWQ9PT11bmRlZmluZWQ/XG4gYFJlbW90ZSR7ZXJyQ29uc3RydWN0b3IubmFtZX1gOlxuIGBSZW1vdGUke2VyckNvbnN0cnVjdG9yLm5hbWV9KCR7ZEVycm9ySWR9KWA7XG5jb25zdCBvcHRpb25zPXtcbmVycm9yTmFtZSxcbnNhbml0aXplOmZhbHNlfTtcblxuaWYoY2F1c2Upe1xub3B0aW9ucy5jYXVzZT1kZWNvZGVSZWN1cihjYXVzZSk7XG4gfVxuaWYoZXJyb3JzKXtcbm9wdGlvbnMuZXJyb3JzPWRlY29kZVJlY3VyKGVycm9ycyk7XG4gfVxuY29uc3QgcmF3RXJyb3I9bWFrZUVycm9yKGRNZXNzYWdlLGVyckNvbnN0cnVjdG9yLG9wdGlvbnMpO1xuLyogTm90ZSB0aGF0IHRoaXMgZG9lcyBub3QgZGVjb2RlUmVjdXIgcmVzdCdzIHByb3BlcnR5IG5hbWVzLiovXG4vKiBUaGlzIHdvdWxkIGJlIGluY29uc2lzdGVudCB3aXRoIHNtYWxsY2FwcycgZXhwZWN0ZWQgaGFuZGxpbmcsKi9cbi8qIGJ1dCBpcyBmaW5lIGhlcmUgc2luY2UgaXQgaXMgb25seSB1c2VkIGZvciBgYW5ub3RhdGVFcnJvcmAsKi9cbi8qIHdoaWNoIGlzIGZvciBkaWFnbm9zdGljIGluZm8gdGhhdCBpcyBvdGhlcndpc2UgdW5vYnNlcnZhYmxlLiovXG5jb25zdCBkZXNjcz1vYmplY3RNYXAocmVzdCwoZGF0YSk9Pih7XG52YWx1ZTpkZWNvZGVSZWN1cihkYXRhKSxcbndyaXRhYmxlOmZhbHNlLFxuZW51bWVyYWJsZTpmYWxzZSxcbmNvbmZpZ3VyYWJsZTpmYWxzZX0pKTtcblxuZGVmaW5lUHJvcGVydGllcyhyYXdFcnJvcixkZXNjcyk7XG5oYXJkZW4ocmF3RXJyb3IpO1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcihyYXdFcnJvcik7XG4gfTtcblxuLyogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaCovXG4vKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb24qL1xuLyogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUqL1xuLyogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNCovXG5jb25zdCBkZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0ocmF3VHJlZSxfZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLnNsb3REYXRhfT1yYXdUcmVlO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oc2xvdERhdGEpO1xuIH07XG5cbmNvbnN0IGRlY29kZUVycm9yRnJvbUNhcERhdGE9KHJhd1RyZWUsZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLmVyckRhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlRXJyb3JDb21tb24oZXJyRGF0YSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbUNhcERhdGE9bWFrZURlY29kZUZyb21DYXBEYXRhKHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IG1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2Fwcz0ocHJlZml4KT0+e1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyaW5nRW5jb2RpbmdcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBfZGVjb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5yZXR1cm4oc3RyaW5nRW5jb2RpbmcsX2RlY29kZVJlY3VyKT0+e1xuYXNzZXJ0KHN0cmluZ0VuY29kaW5nLmNoYXJBdCgwKT09PXByZWZpeCk7XG4vKiBzbG90czogJHNsb3RJbmRleC5pZmFjZSBvciAkc2xvdEluZGV4Ki9cbmNvbnN0IGk9c3RyaW5nRW5jb2RpbmcuaW5kZXhPZignLicpO1xuY29uc3QgaW5kZXg9TnVtYmVyKHN0cmluZ0VuY29kaW5nLnNsaWNlKDEsaTwwP3VuZGVmaW5lZDppKSk7XG4vKiBpIDwgMCBtZWFucyB0aGVyZSB3YXMgbm8gaWZhY2UgaW5jbHVkZWQuKi9cbmNvbnN0IGlmYWNlPWk8MD91bmRlZmluZWQ6c3RyaW5nRW5jb2Rpbmcuc2xpY2UoaSsxKTtcbnJldHVybiBkZWNvZGVTbG90Q29tbW9uKHtpZmFjZSxpbmRleH0pO1xuIH07XG4gfTtcbmNvbnN0IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzKCckJyk7XG5jb25zdCBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyYnKTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyxkZWNvZGVSZWN1cik9PntcbmNvbnN0eycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdEVyckRhdGF9PWVuY29kaW5nO1xuIWhhc093blByb3BlcnR5T2YocmVzdEVyckRhdGEsJ21lc3NhZ2UnKXx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgZXJyb3IgcHJvcGVydHkgJHtxKCdtZXNzYWdlJyl9YDtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbih7bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX0sZGVjb2RlUmVjdXIpO1xuIH07XG5cbmNvbnN0IHJldml2ZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZUZyb21TbWFsbGNhcHMoe1xuLyogQHRzLWlnbm9yZSBYWFggU21hbGxDYXBzRW5jb2RpbmcqL1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcyxcbi8qIEB0cy1pZ25vcmUgWFhYIFNtYWxsQ2Fwc0VuY29kaW5nKi9cbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc30pO1xuIH07XG5cbi8qKlxuICogQHR5cGUge0Zyb21DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCBmcm9tQ2FwRGF0YT0oZGF0YSk9PntcbmNvbnN0e2JvZHksc2xvdHN9PWRhdGE7XG50eXBlb2YgYm9keT09PSdzdHJpbmcnfHxcbkZhaWwgYHVuc2VyaWFsaXplKCkgZ2l2ZW4gbm9uLWNhcGRhdGEgKC5ib2R5IGlzICR7Ym9keX0sIG5vdCBzdHJpbmcpYDtcbmlzQXJyYXkoZGF0YS5zbG90cyl8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLnNsb3RzIGFyZSBub3QgQXJyYXkpYDtcbmNvbnN0e3Jldml2ZUZyb21DYXBEYXRhLHJldml2ZUZyb21TbWFsbGNhcHN9PW1ha2VGdWxsUmV2aXZlKHNsb3RzKTtcbmxldCByZXN1bHQ7XG4vKiBKU09OIGNhbm5vdCBiZWdpbiB3aXRoIGEgJyMnLCBzbyB0aGlzIGlzIGFuIHVuYW1iaWd1b3VzIHNpZ25hbC4qL1xuaWYoYm9keS5jaGFyQXQoMCk9PT0nIycpe1xuY29uc3Qgc21hbGxjYXBzQm9keT1ib2R5LnNsaWNlKDEpO1xuY29uc3QgZW5jb2Rpbmc9aGFyZGVuKEpTT04ucGFyc2Uoc21hbGxjYXBzQm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tU21hbGxjYXBzKGVuY29kaW5nKSk7XG4gfWVsc2V7XG5jb25zdCByYXdUcmVlPWhhcmRlbihKU09OLnBhcnNlKGJvZHkpKTtcbnJlc3VsdD1oYXJkZW4ocmV2aXZlRnJvbUNhcERhdGEocmF3VHJlZSkpO1xuIH1cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzcqL1xuLyogd2hpY2ggc2hvdWxkIGJlIGNvbnNpZGVyZWQgZml4ZWQgb25jZSB3ZSd2ZSBjb21wbGV0ZWQgdGhlIHN3aXRjaCovXG4vKiB0byBzbWFsbGNhcHMuKi9cbmFzc2VydFBhc3NhYmxlKHJlc3VsdCk7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc2FibGVDYXB9ICovcmVzdWx0KTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtcbnRvQ2FwRGF0YSxcbmZyb21DYXBEYXRhLFxuXG4vKiBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkqL1xuLyoqIEBkZXByZWNhdGVkIHVzZSB0b0NhcERhdGEgKi9cbnNlcmlhbGl6ZTp0b0NhcERhdGEsXG4vKiogQGRlcHJlY2F0ZWQgdXNlIGZyb21DYXBEYXRhICovXG51bnNlcmlhbGl6ZTpmcm9tQ2FwRGF0YX0pO1xuXG4gfTskaM2PX29uY2UubWFrZU1hcnNoYWwobWFrZU1hcnNoYWwpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZU1hcnNoYWwiOlsibWFrZU1hcnNoYWwiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZrtByttBAADbQQAAJQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyIsIi4vZW5jb2RlUGFzc2FibGUuanMiXSwiZXhwb3J0cyI6WyJGdWxsUmFua0NvdmVyIiwiYXNzZXJ0UmFua1NvcnRlZCIsImNvbXBhcmF0b3JNaXJyb3JJbWFnZSIsImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVSYW5rIiwiY292ZXJlZEVudHJpZXMiLCJnZXRJbmRleENvdmVyIiwiZ2V0UGFzc1N0eWxlQ292ZXIiLCJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaXNSYW5rU29ydGVkIiwibWFrZUNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsInNvcnRCeVJhbmsiLCJ0cml2aWFsQ29tcGFyYXRvciIsInVuaW9uUmFua0NvdmVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBnZXRUYWcscGFzc1N0eWxlT2YsbmFtZUZvclBhc3NhYmxlU3ltYm9sLEZhaWwscSxwYXNzU3R5bGVQcmVmaXhlcyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVBhc3NhYmxlLmpzXCIsIFtbXCJwYXNzU3R5bGVQcmVmaXhlc1wiLCBbJGjNj19hID0+IChwYXNzU3R5bGVQcmVmaXhlcyA9ICRozY9fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjNj19hID0+IChyZWNvcmROYW1lcyA9ICRozY9fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRozY9fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUGFzc1N0eWxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJ1xuICogQGltcG9ydCB7RnVsbENvbXBhcmUsIFBhcnRpYWxDb21wYXJlLCBQYXJ0aWFsQ29tcGFyaXNvbiwgUmFua0NvbXBhcmUsIFJhbmtDb3Zlcn0gZnJvbSAnLi90eXBlcy5qcydcbiAqL1xuXG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLHNldFByb3RvdHlwZU9mLGlzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmFua0NvbXBhcmF0b3JLaXRcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGFudGlDb21wYXJhdG9yXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGdWxsQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtbbnVtYmVyLCBudW1iZXJdfSBJbmRleENvdmVyXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBlcXVhbGl0eSBjb21wYXJpc29uIHVzZWQgYnkgSmF2YVNjcmlwdCdzIE1hcCBhbmQgU2V0XG4gKiBhYnN0cmFjdGlvbnMsIHdoZXJlIE5hTiBpcyB0aGUgc2FtZSBhcyBOYU4gYW5kIC0wIGlzIHRoZSBzYW1lIGFzXG4gKiAwLiBNYXJzaGFsIHNlcmlhbGl6ZXMgLTAgYXMgemVybywgc28gdGhlIHNlbWFudGljcyBvZiBvdXIgZGlzdHJpYnV0ZWRcbiAqIG9iamVjdCBzeXN0ZW0gZG9lcyBub3QgZGlzdGluZ3Vpc2ggMCBmcm9tIC0wLlxuICpcbiAqIGBzYW1lVmFsdWVaZXJvYCBpcyB0aGUgRWNtYVNjcmlwdCBzcGVjIG5hbWUgZm9yIHRoaXMgZXF1YWxpdHkgY29tcGFyaXNvbixcbiAqIGJ1dCBUT0RPIHdlIG5lZWQgYSBiZXR0ZXIgbmFtZSBmb3IgdGhlIEFQSS5cbiAqXG4gKiBAcGFyYW0ge2FueX0geFxuICogQHBhcmFtIHthbnl9IHlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzYW1lVmFsdWVaZXJvPSh4LHkpPT54PT09eXx8aXMoeCx5KTtcblxuY29uc3QgICAgICAgIHRyaXZpYWxDb21wYXJhdG9yPShsZWZ0LHJpZ2h0KT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnksIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMqL1xubGVmdDxyaWdodD8tMTpsZWZ0PT09cmlnaHQ/MDoxO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8UGFzc1N0eWxlLCB7IGluZGV4OiBudW1iZXIsIGNvdmVyOiBSYW5rQ292ZXIgfT59IFBhc3NTdHlsZVJhbmtzUmVjb3JkXG4gKi8kaM2PX29uY2UudHJpdmlhbENvbXBhcmF0b3IodHJpdmlhbENvbXBhcmF0b3IpO1xuXG5jb25zdCBwYXNzU3R5bGVSYW5rcz0vKiogQHR5cGUge1Bhc3NTdHlsZVJhbmtzUmVjb3JkfSAqL1xuZnJvbUVudHJpZXMoXG5lbnRyaWVzKHBhc3NTdHlsZVByZWZpeGVzKVxuLyogU29ydCBlbnRyaWVzIGJ5IGFzY2VuZGluZyBwcmVmaXguKi8uXG5zb3J0KChbX2xlZnRTdHlsZSxsZWZ0UHJlZml4ZXNdLFtfcmlnaHRTdHlsZSxyaWdodFByZWZpeGVzXSk9PntcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihsZWZ0UHJlZml4ZXMscmlnaHRQcmVmaXhlcyk7XG4gfSkuXG5tYXAoKFtwYXNzU3R5bGUscHJlZml4ZXNdLGluZGV4KT0+e1xuLyogQ292ZXIgYWxsIHN0cmluZ3MgdGhhdCBzdGFydCB3aXRoIGFueSBjaGFyYWN0ZXIgaW4gYHByZWZpeGVzYCwqL1xuLyogdmVyaWZ5aW5nIHRoYXQgaXQgaXMgc29ydGVkIHNvIHRoYXQgaXMqL1xuLyogYWxsIHMgc3VjaCB0aGF0IHByZWZpeGVzLmF0KDApIOKJpCBzIDwgc3VjY2Vzc29yKHByZWZpeGVzLmF0KC0xKSkuKi9cbnByZWZpeGVzPT09Wy4uLnByZWZpeGVzXS5zb3J0KCkuam9pbignJyl8fFxuRmFpbCBgdW5zb3J0ZWQgcHJlZml4ZXMgZm9yIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7cShwcmVmaXhlcyl9YDtcbmNvbnN0IGNvdmVyPVtcbnByZWZpeGVzLmNoYXJBdCgwKSxcblN0cmluZy5mcm9tQ2hhckNvZGUocHJlZml4ZXMuY2hhckNvZGVBdChwcmVmaXhlcy5sZW5ndGgtMSkrMSldO1xuXG5yZXR1cm5bcGFzc1N0eWxlLHtpbmRleCxjb3Zlcn1dO1xuIH0pKTtcblxuXG5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVSYW5rcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVSYW5rcyk7XG5cbi8qKlxuICogQXNzb2NpYXRlIHdpdGggZWFjaCBwYXNzU3R5bGUgYSBSYW5rQ292ZXIgdGhhdCBtYXkgYmUgYW4gb3ZlcmVzdGltYXRlLFxuICogYW5kIHdob3NlIHJlc3VsdHMgdGhlcmVmb3JlIG5lZWQgdG8gYmUgZmlsdGVyZWQgZG93bi4gRm9yIGV4YW1wbGUsIGJlY2F1c2VcbiAqIHRoZXJlIGlzIG5vdCBhIHNtYWxsZXN0IG9yIGJpZ2dlc3QgYmlnaW50LCBib3VuZCBpdCBieSBgTmFOYCAodGhlIGxhc3QgcGxhY2VcbiAqIG51bWJlcikgYW5kIGAnJ2AgKHRoZSBlbXB0eSBzdHJpbmcsIHdoaWNoIGlzIHRoZSBmaXJzdCBwbGFjZSBzdHJpbmcpLiBUaHVzLFxuICogYSByYW5nZSBxdWVyeSB1c2luZyB0aGlzIHJhbmdlIG1heSBpbmNsdWRlIHRoZXNlIHZhbHVlcywgd2hpY2ggd291bGQgdGhlblxuICogbmVlZCB0byBiZSBmaWx0ZXJlZCBvdXQuXG4gKlxuICogQHBhcmFtIHtQYXNzU3R5bGV9IHBhc3NTdHlsZVxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldFBhc3NTdHlsZUNvdmVyPShwYXNzU3R5bGUpPT5wYXNzU3R5bGVSYW5rc1twYXNzU3R5bGVdLmNvdmVyOyRozY9fb25jZS5nZXRQYXNzU3R5bGVDb3ZlcihnZXRQYXNzU3R5bGVDb3Zlcik7XG5oYXJkZW4oZ2V0UGFzc1N0eWxlQ292ZXIpO1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPFJhbmtDb21wYXJlLFdlYWtTZXQ8UGFzc2FibGVbXT4+fVxuICovXG5jb25zdCBtZW1vT2ZTb3J0ZWQ9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxSYW5rQ29tcGFyZT59XG4gKi9cbmNvbnN0IGNvbXBhcmF0b3JNaXJyb3JJbWFnZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhcnRpYWxDb21wYXJlfSBbY29tcGFyZVJlbW90YWJsZXNdXG4gKiBBIGNvbXBhcmF0b3IgZm9yIGFzc2lnbmluZyBhbiBpbnRlcm5hbCBvcmRlciB0byByZW1vdGFibGVzLlxuICogSXQgZGVmYXVsdHMgdG8gYSBmdW5jdGlvbiB0aGF0IGFsd2F5cyByZXR1cm5zIGBOYU5gLCBtZWFuaW5nIHRoYXQgYWxsXG4gKiByZW1vdGFibGVzIGFyZSBpbmNvbXBhcmFibGUgYW5kIHNob3VsZCB0aWUgZm9yIHRoZSBzYW1lIHJhbmsgYnlcbiAqIHNob3J0LWNpcmN1aXRpbmcgd2l0aG91dCBmdXJ0aGVyIHJlZmluZW1lbnQgKGUuZy4sIG5vdCBvbmx5IGFyZSBgcjFgIGFuZCBgcjJgXG4gKiB0aWVkLCBidXQgc28gYXJlIGBbcjEsIDBdYCBhbmQgYFtyMiwgXCJ4XCJdYCkuXG4gKiBAcmV0dXJucyB7UmFua0NvbXBhcmF0b3JLaXR9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29tcGFyYXRvcktpdD0oY29tcGFyZVJlbW90YWJsZXM9KF94LF95KT0+TmFOKT0+e1xuLyoqIEB0eXBlIHtQYXJ0aWFsQ29tcGFyZX0gKi9cbmNvbnN0IGNvbXBhcmF0b3I9KGxlZnQscmlnaHQpPT57XG5pZihzYW1lVmFsdWVaZXJvKGxlZnQscmlnaHQpKXtcbnJldHVybiAwO1xuIH1cbmNvbnN0IGxlZnRTdHlsZT1wYXNzU3R5bGVPZihsZWZ0KTtcbmNvbnN0IHJpZ2h0U3R5bGU9cGFzc1N0eWxlT2YocmlnaHQpO1xuaWYobGVmdFN0eWxlIT09cmlnaHRTdHlsZSl7XG5yZXR1cm4gdHJpdmlhbENvbXBhcmF0b3IoXG5wYXNzU3R5bGVSYW5rc1tsZWZ0U3R5bGVdLmluZGV4LFxucGFzc1N0eWxlUmFua3NbcmlnaHRTdHlsZV0uaW5kZXgpO1xuXG4gfVxuLyogZXNsaW50LWRpc2FibGUgQGVuZG8vcmVzdHJpY3QtY29tcGFyaXNvbi1vcGVyYW5kcyAtLVxuICogV2Uga25vdyBgbGVmdGAgYW5kIGByaWdodGAgYXJlIGNvbXBhcmFibGUuXG4gKi9cbnN3aXRjaChsZWZ0U3R5bGUpe1xuY2FzZSdyZW1vdGFibGUnOntcbnJldHVybiBjb21wYXJlUmVtb3RhYmxlcyhsZWZ0LHJpZ2h0KTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ251bGwnOlxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbi8qIEZvciBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIGFsbCBtZW1iZXJzIG9mIHRoYXQgcGFzc1N0eWxlIGFyZSB0aWVkKi9cbi8qIGZvciB0aGUgc2FtZSByYW5rLiovXG5yZXR1cm4gMDtcbiB9XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOntcbi8qIFdpdGhpbiBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIHRoZSByYW5rIG9yZGVyaW5nIGFncmVlcyB3aXRoKi9cbi8qIEphdmFTY3JpcHQncyByZWxhdGlvbmFsIG9wZXJhdG9ycyBgPGAgYW5kIGA+YC4qL1xuaWYobGVmdDxyaWdodCl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbmFzc2VydChsZWZ0PnJpZ2h0KTtcbnJldHVybiAxO1xuIH1cbiB9XG5jYXNlJ3N5bWJvbCc6e1xucmV0dXJuIGNvbXBhcmF0b3IoXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wobGVmdCksXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wocmlnaHQpKTtcblxuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBgTmFOYCdzIHJhbmsgaXMgYWZ0ZXIgYWxsIG90aGVyIG51bWJlcnMuKi9cbmlmKE51bWJlci5pc05hTihsZWZ0KSl7XG5hc3NlcnQoIU51bWJlci5pc05hTihyaWdodCkpO1xucmV0dXJuIDE7XG4gfWVsc2UgaWYoTnVtYmVyLmlzTmFOKHJpZ2h0KSl7XG5yZXR1cm4tMTtcbiB9XG4vKiBUaGUgcmFuayBvcmRlcmluZyBvZiBub24tTmFOIG51bWJlcnMgYWdyZWVzIHdpdGggSmF2YVNjcmlwdCdzKi9cbi8qIHJlbGF0aW9uYWwgb3BlcmF0b3JzICc8JyBhbmQgJz4nLiovXG5pZihsZWZ0PHJpZ2h0KXtcbnJldHVybi0xO1xuIH1lbHNle1xuYXNzZXJ0KGxlZnQ+cmlnaHQpO1xucmV0dXJuIDE7XG4gfVxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBpbnZlcnNlIHNvcnRlZCBvcmRlciBvZiBwcm9wZXJ0eSBuYW1lcywgdGhlbiovXG4vKiBsZXhpY29ncmFwaGljIGJ5IGNvcnJlc3BvbmRpbmcgdmFsdWVzIGluIHRoYXQgc2FtZSBpbnZlcnNlKi9cbi8qIG9yZGVyIG9mIHRoZWlyIHByb3BlcnR5IG5hbWVzLiBDb21wYXJpbmcgbmFtZXMgYnkgdGhlbXNlbHZlcyBmaXJzdCwqL1xuLyogYWxsIHJlY29yZHMgd2l0aCB0aGUgZXhhY3Qgc2FtZSBzZXQgb2YgcHJvcGVydHkgbmFtZXMgc29ydCBuZXh0IHRvKi9cbi8qIGVhY2ggb3RoZXIgaW4gYSByYW5rLXNvcnQgb2YgY29weVJlY29yZHMuKi9cblxuLyogVGhlIGNvcHlSZWNvcmQgaW52YXJpYW50cyBlbmZvcmNlZCBieSBwYXNzU3R5bGVPZiBlbnN1cmUgdGhhdCovXG4vKiBhbGwgdGhlIHByb3BlcnR5IG5hbWVzIGFyZSBzdHJpbmdzLiBXZSBuZWVkIHRoZSByZXZlcnNlIHNvcnRlZCBvcmRlciovXG4vKiBvZiB0aGVzZSBuYW1lcywgd2hpY2ggd2UgdGhlbiBjb21wYXJlIGxleGljb2dyYXBoaWNhbGx5LiBUaGlzIGVuc3VyZXMqL1xuLyogdGhhdCBpZiB0aGUgbmFtZXMgb2YgcmVjb3JkIFggYXJlIGEgc3Vic2V0IG9mIHRoZSBuYW1lcyBvZiByZWNvcmQgWSwqL1xuLyogdGhlbiByZWNvcmQgWCB3aWxsIGhhdmUgYW4gZWFybGllciByYW5rIGFuZCBzb3J0IHRvIHRoZSBsZWZ0IG9mIFkuKi9cbmNvbnN0IGxlZnROYW1lcz1yZWNvcmROYW1lcyhsZWZ0KTtcbmNvbnN0IHJpZ2h0TmFtZXM9cmVjb3JkTmFtZXMocmlnaHQpO1xuXG5jb25zdCByZXN1bHQ9Y29tcGFyYXRvcihsZWZ0TmFtZXMscmlnaHROYW1lcyk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuY29uc3QgbGVmdFZhbHVlcz1yZWNvcmRWYWx1ZXMobGVmdCxsZWZ0TmFtZXMpO1xuY29uc3QgcmlnaHRWYWx1ZXM9cmVjb3JkVmFsdWVzKHJpZ2h0LHJpZ2h0TmFtZXMpO1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdFZhbHVlcyxyaWdodFZhbHVlcyk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMqL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnRbaV0scmlnaHRbaV0pO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG4vKiBJZiBhbGwgbWF0Y2hpbmcgZWxlbWVudHMgd2VyZSB0aWVkLCB0aGVuIGFjY29yZGluZyB0byB0aGVpciBsZW5ndGhzLiovXG4vKiBJZiBhcnJheSBYIGlzIGEgcHJlZml4IG9mIGFycmF5IFksIHRoZW4gWCBoYXMgYW4gZWFybGllciByYW5rIHRoYW4gWS4qL1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBgW1N5bWJvbC50b1N0cmluZ1RhZ11gIHRoZW4gYC5wYXlsb2FkYC4qL1xuY29uc3QgbGFiZWxDb21wPWNvbXBhcmF0b3IoZ2V0VGFnKGxlZnQpLGdldFRhZyhyaWdodCkpO1xuaWYobGFiZWxDb21wIT09MCl7XG5yZXR1cm4gbGFiZWxDb21wO1xuIH1cbnJldHVybiBjb21wYXJhdG9yKGxlZnQucGF5bG9hZCxyaWdodC5wYXlsb2FkKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBwYXNzU3R5bGU6ICR7cShsZWZ0U3R5bGUpfWA7XG4gfX1cblxuLyogZXNsaW50LWVuYWJsZSAqL1xuIH07XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBvdXRlckNvbXBhcmF0b3I9KHgseSk9PlxuLyogV2hlbiB0aGUgaW5uZXIgY29tcGFyYXRvciByZXR1cm5zIE5hTiB0byBpbmRpY2F0ZSBpbmNvbXBhcmFiaWxpdHksKi9cbi8qIHJlcGxhY2UgdGhhdCB3aXRoIDAgdG8gaW5kaWNhdGUgYSB0aWUuKi9cbi8qKiBAdHlwZSB7RXhjbHVkZTxQYXJ0aWFsQ29tcGFyaXNvbiwgTmFOPn0gKi9jb21wYXJhdG9yKHgseSl8fDA7XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBhbnRpQ29tcGFyYXRvcj0oeCx5KT0+b3V0ZXJDb21wYXJhdG9yKHkseCk7XG5cbm1lbW9PZlNvcnRlZC5zZXQob3V0ZXJDb21wYXJhdG9yLG5ldyBXZWFrU2V0KCkpO1xubWVtb09mU29ydGVkLnNldChhbnRpQ29tcGFyYXRvcixuZXcgV2Vha1NldCgpKTtcbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuc2V0KG91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcik7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChhbnRpQ29tcGFyYXRvcixvdXRlckNvbXBhcmF0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtjb21wYXJhdG9yOm91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcn0pO1xuIH07XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEByZXR1cm5zIHtSYW5rQ29tcGFyZT19XG4gKi8kaM2PX29uY2UubWFrZUNvbXBhcmF0b3JLaXQobWFrZUNvbXBhcmF0b3JLaXQpO1xuY29uc3QgICAgICAgIGNvbXBhcmF0b3JNaXJyb3JJbWFnZT0oY29tcGFyYXRvcik9PlxuY29tcGFyYXRvck1pcnJvckltYWdlcy5nZXQoY29tcGFyYXRvcik7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjNj19vbmNlLmNvbXBhcmF0b3JNaXJyb3JJbWFnZShjb21wYXJhdG9yTWlycm9ySW1hZ2UpO1xuY29uc3QgICAgICAgIGlzUmFua1NvcnRlZD0ocGFzc2FibGVzLGNvbXBhcmUpPT57XG5jb25zdCBzdWJNZW1vT2ZTb3J0ZWQ9bWVtb09mU29ydGVkLmdldChjb21wYXJlKTtcbmFzc2VydChzdWJNZW1vT2ZTb3J0ZWQhPT11bmRlZmluZWQpO1xuaWYoc3ViTWVtb09mU29ydGVkLmhhcyhwYXNzYWJsZXMpKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydChwYXNzU3R5bGVPZihwYXNzYWJsZXMpPT09J2NvcHlBcnJheScpO1xuZm9yKGxldCBpPTE7aTxwYXNzYWJsZXMubGVuZ3RoO2krPTEpe1xuaWYoY29tcGFyZShwYXNzYWJsZXNbaS0xXSxwYXNzYWJsZXNbaV0pPj0xKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuc3ViTWVtb09mU29ydGVkLmFkZChwYXNzYWJsZXMpO1xucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNSYW5rU29ydGVkKGlzUmFua1NvcnRlZCk7XG5oYXJkZW4oaXNSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UmFua1NvcnRlZD0oc29ydGVkLGNvbXBhcmUpPT5cbmlzUmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSl8fFxuLyogVE9ETyBhc3NlcnQgb24gYnVnIGNvdWxkIGxlYWQgdG8gaW5maW5pdGUgcmVjdXJzaW9uLiBGaXguKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5GYWlsIGBNdXN0IGJlIHJhbmsgc29ydGVkOiAke3NvcnRlZH0gdnMgJHtzb3J0QnlSYW5rKHNvcnRlZCxjb21wYXJlKX1gOyRozY9fb25jZS5hc3NlcnRSYW5rU29ydGVkKGFzc2VydFJhbmtTb3J0ZWQpO1xuaGFyZGVuKGFzc2VydFJhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHBhc3NhYmxlc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHNvcnRCeVJhbms9KHBhc3NhYmxlcyxjb21wYXJlKT0+e1xuaWYoQXJyYXkuaXNBcnJheShwYXNzYWJsZXMpKXtcbmhhcmRlbihwYXNzYWJsZXMpO1xuLyogQ2FsbGluZyBpc1JhbmtTb3J0ZWQgZ2l2ZXMgaXQgYSBjaGFuY2UgdG8gZ2V0IG1lbW9pemVkIGZvciovXG4vKiB0aGlzIGBjb21wYXJlYCBmdW5jdGlvbiBldmVuIGlmIGl0IHdhcyBhbHJlYWR5IG1lbW9pemVkIGZvciBhIGRpZmZlcmVudCovXG4vKiBgY29tcGFyZWAgZnVuY3Rpb24uKi9cbmlmKGlzUmFua1NvcnRlZChwYXNzYWJsZXMsY29tcGFyZSkpe1xucmV0dXJuIHBhc3NhYmxlcztcbiB9XG4gfVxuY29uc3QgdW5zb3J0ZWQ9Wy4uLnBhc3NhYmxlc107XG51bnNvcnRlZC5mb3JFYWNoKGhhcmRlbik7XG5jb25zdCBzb3J0ZWQ9dW5zb3J0ZWQuc29ydChjb21wYXJlKTtcbi8qIEZvciByZXZlcnNlIGNvbXBhcmlzb24sIG1vdmUgYHVuZGVmaW5lZGAgdmFsdWVzIGZyb20gdGhlIGVuZCB0byB0aGUgc3RhcnQuKi9cbi8qIE5vdGUgdGhhdCBwYXNzU3R5bGVQcmVmaXhlcyAoQHNlZSB7QGxpbmsgLi9lbmNvZGVQYXNzYWJsZS5qc30pIE1VU1QgTk9UKi9cbi8qIHNvcnQgYW55IGNhdGVnb3J5IGFmdGVyIGB1bmRlZmluZWRgLiovXG5pZihjb21wYXJlKHRydWUsdW5kZWZpbmVkKT4wKXtcbmxldCBpPXNvcnRlZC5sZW5ndGgtMTtcbndoaWxlKGk+PTAmJnNvcnRlZFtpXT09PXVuZGVmaW5lZClpLT0xO1xuY29uc3Qgbj1zb3J0ZWQubGVuZ3RoLWktMTtcbmlmKG4+MCYmbjxzb3J0ZWQubGVuZ3RoKXtcbnNvcnRlZC5jb3B5V2l0aGluKG4sMCk7XG5zb3J0ZWQuZmlsbCgvKiogQHR5cGUge1R9ICovdW5kZWZpbmVkLDAsbik7XG4gfVxuIH1cbmhhcmRlbihzb3J0ZWQpO1xuY29uc3Qgc3ViTWVtb09mU29ydGVkPW1lbW9PZlNvcnRlZC5nZXQoY29tcGFyZSk7XG5hc3NlcnQoc3ViTWVtb09mU29ydGVkIT09dW5kZWZpbmVkKTtcbnN1Yk1lbW9PZlNvcnRlZC5hZGQoc29ydGVkKTtcbnJldHVybiBzb3J0ZWQ7XG4gfTskaM2PX29uY2Uuc29ydEJ5UmFuayhzb3J0QnlSYW5rKTtcbmhhcmRlbihzb3J0QnlSYW5rKTtcblxuLyoqXG4gKiBTZWVcbiAqIGh0dHBzOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0JpbmFyeV9zZWFyY2hfYWxnb3JpdGhtI1Byb2NlZHVyZV9mb3JfZmluZGluZ190aGVfbGVmdG1vc3RfZWxlbWVudFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBrZXlcbiAqIEBwYXJhbSB7KFwibGVmdE1vc3RcIiB8IFwicmlnaHRNb3N0XCIpPX0gYmlhc1xuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmFua1NlYXJjaD0oc29ydGVkLGNvbXBhcmUsa2V5LGJpYXM9J2xlZnRNb3N0Jyk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xubGV0IGxlZnQ9MDtcbmxldCByaWdodD1zb3J0ZWQubGVuZ3RoO1xud2hpbGUobGVmdDxyaWdodCl7XG5jb25zdCBtPU1hdGguZmxvb3IoKGxlZnQrcmlnaHQpLzIpO1xuY29uc3QgY29tcD1jb21wYXJlKHNvcnRlZFttXSxrZXkpO1xuaWYoY29tcDw9LTF8fGNvbXA9PT0wJiZiaWFzPT09J3JpZ2h0TW9zdCcpe1xubGVmdD1tKzE7XG4gfWVsc2V7XG5hc3NlcnQoY29tcD49MXx8Y29tcD09PTAmJmJpYXM9PT0nbGVmdE1vc3QnKTtcbnJpZ2h0PW07XG4gfVxuIH1cbnJldHVybiBiaWFzPT09J2xlZnRNb3N0Jz9sZWZ0OnJpZ2h0LTE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IHJhbmtDb3ZlclxuICogQHJldHVybnMge0luZGV4Q292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbmRleENvdmVyPShzb3J0ZWQsY29tcGFyZSxbbGVmdEtleSxyaWdodEtleV0pPT57XG5hc3NlcnRSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKTtcbmNvbnN0IGxlZnRJbmRleD1yYW5rU2VhcmNoKHNvcnRlZCxjb21wYXJlLGxlZnRLZXksJ2xlZnRNb3N0Jyk7XG5jb25zdCByaWdodEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUscmlnaHRLZXksJ3JpZ2h0TW9zdCcpO1xucmV0dXJuW2xlZnRJbmRleCxyaWdodEluZGV4XTtcbiB9OyRozY9fb25jZS5nZXRJbmRleENvdmVyKGdldEluZGV4Q292ZXIpO1xuaGFyZGVuKGdldEluZGV4Q292ZXIpO1xuXG4vKiogQHR5cGUge1JhbmtDb3Zlcn0gKi9cbmNvbnN0ICAgICAgICBGdWxsUmFua0NvdmVyPWhhcmRlbihbJycsJ3snXSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7SW5kZXhDb3Zlcn0gaW5kZXhDb3ZlclxuICogQHJldHVybnMge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59XG4gKi8kaM2PX29uY2UuRnVsbFJhbmtDb3ZlcihGdWxsUmFua0NvdmVyKTtcbmNvbnN0ICAgICAgICBjb3ZlcmVkRW50cmllcz0oc29ydGVkLFtsZWZ0SW5kZXgscmlnaHRJbmRleF0pPT57XG4vKiogQHR5cGUge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59ICovXG5jb25zdCBpdGVyYWJsZT1oYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmxldCBpPWxlZnRJbmRleDtcbnJldHVybiBoYXJkZW4oe1xubmV4dDooKT0+e1xuaWYoaTw9cmlnaHRJbmRleCl7XG5jb25zdCBlbGVtZW50PXNvcnRlZFtpXTtcbmkrPTE7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTpbaSxlbGVtZW50XSxkb25lOmZhbHNlfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTp1bmRlZmluZWQsZG9uZTp0cnVlfSk7XG4gfVxuIH19KTtcblxuIH19KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjNj19vbmNlLmNvdmVyZWRFbnRyaWVzKGNvdmVyZWRFbnRyaWVzKTtcbmhhcmRlbihjb3ZlcmVkRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtYXhSYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKT49MD9hOmI7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtaW5SYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKTw9MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgdW5pb25SYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCB1bmlvblJhbmtDb3ZlclBhaXI9KFtsZWZ0QSxyaWdodEFdLFtsZWZ0QixyaWdodEJdKT0+W1xubWluUmFuayhjb21wYXJlLGxlZnRBLGxlZnRCKSxcbm1heFJhbmsoY29tcGFyZSxyaWdodEEscmlnaHRCKV07XG5cbnJldHVybiBjb3ZlcnMucmVkdWNlKHVuaW9uUmFua0NvdmVyUGFpcixbJ3snLCcnXSk7XG4gfTskaM2PX29uY2UudW5pb25SYW5rQ292ZXJzKHVuaW9uUmFua0NvdmVycyk7XG5oYXJkZW4odW5pb25SYW5rQ292ZXJzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpbnRlcnNlY3RSYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCBpbnRlcnNlY3RSYW5rQ292ZXJQYWlyPShbbGVmdEEscmlnaHRBXSxbbGVmdEIscmlnaHRCXSk9Pltcbm1heFJhbmsoY29tcGFyZSxsZWZ0QSxsZWZ0QiksXG5taW5SYW5rKGNvbXBhcmUscmlnaHRBLHJpZ2h0QildO1xuXG5yZXR1cm4gY292ZXJzLnJlZHVjZShpbnRlcnNlY3RSYW5rQ292ZXJQYWlyLFsnJywneyddKTtcbiB9OyRozY9fb25jZS5pbnRlcnNlY3RSYW5rQ292ZXJzKGludGVyc2VjdFJhbmtDb3ZlcnMpO1xuXG5jb25zdCAgICAgICB7Y29tcGFyYXRvcjpjb21wYXJlUmFuayxhbnRpQ29tcGFyYXRvcjpjb21wYXJlQW50aVJhbmt9PVxubWFrZUNvbXBhcmF0b3JLaXQoKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjb21wYXJhdG9yIGtpdCBpbiB3aGljaCByZW1vdGFibGVzIGFyZSBmdWxseSBvcmRlcmVkXG4gKiBieSB0aGUgb3JkZXIgaW4gd2hpY2ggdGhleSBhcmUgZmlyc3Qgc2VlbiBieSAqdGhpcyogY29tcGFyYXRvciBraXQuXG4gKiBCRVdBUkU6IFRoaXMgaXMgb2JzZXJ2YWJsZSBtdXRhYmxlIHN0YXRlLCBzbyBzdWNoIGEgY29tcGFyYXRvciBraXRcbiAqIHNob3VsZCBuZXZlciBiZSBzaGFyZWQgYW1vbmcgc3Vic3lzdGVtcyB0aGF0IHNob3VsZCBub3QgYmUgYWJsZVxuICogdG8gY29tbXVuaWNhdGUuXG4gKlxuICogTm90ZSB0aGF0IHRoaXMgb3JkZXIgZG9lcyBub3QgbWVldCB0aGUgcmVxdWlyZW1lbnRzIGZvciBzdG9yZVxuICogb3JkZXJpbmcsIHNpbmNlIGl0IGhhcyBubyBtZW1vcnkgb2YgZGVsZXRlZCBrZXlzLlxuICpcbiAqIFRoZXNlIGZ1bGwgb3JkZXIgY29tcGFyYXRvciBraXQgaXMgc3RyaWN0bHkgbW9yZSBwcmVjaXNlIHRoYXQgdGhlXG4gKiByYW5rIG9yZGVyIGNvbXBhcmF0b3Iga2l0cyBhYm92ZS4gQXMgYSByZXN1bHQsIGFueSBhcnJheSB3aGljaCBpc1xuICogc29ydGVkIGJ5IHN1Y2ggYSBmdWxsIG9yZGVyIHdpbGwgcGFzcyB0aGUgaXNSYW5rU29ydGVkIHRlc3Qgd2l0aFxuICogYSBjb3JyZXNwb25kaW5nIHJhbmsgb3JkZXIuXG4gKlxuICogQW4gYXJyYXkgd2hpY2ggaXMgc29ydGVkIGJ5IGEgKmZyZXNoKiBmdWxsIG9yZGVyIGNvbXBhcmF0b3IsIGkuZS4sXG4gKiBvbmUgdGhhdCBoYXMgbm90IHlldCBzZWVuIGFueSByZW1vdGFibGVzLCB3aWxsIG9mIGNvdXJzZSByZW1haW5cbiAqIHNvcnRlZCBieSBhY2NvcmRpbmcgdG8gKnRoYXQqIGZ1bGwgb3JkZXIgY29tcGFyYXRvci4gQW4gYXJyYXkgKm9mXG4gKiBzY2FsYXJzKiBzb3J0ZWQgYnkgYSBmcmVzaCBmdWxsIG9yZGVyIHdpbGwgcmVtYWluIHNvcnRlZCBldmVuXG4gKiBhY2NvcmRpbmcgdG8gYSBuZXcgZnJlc2ggZnVsbCBvcmRlciBjb21wYXJhdG9yLCBzaW5jZSBpdCB3aWxsIHNlZVxuICogdGhlIHJlbW90YWJsZXMgaW4gdGhlIHNhbWUgb3JkZXIgYWdhaW4uIFVuZm9ydHVuYXRlbHksIHRoaXMgaXNcbiAqIG5vdCB0cnVlIG9mIGFycmF5cyBvZiBwYXNzYWJsZXMgaW4gZ2VuZXJhbC5cbiAqXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBsb25nTGl2ZWRcbiAqIEByZXR1cm5zIHtGdWxsQ29tcGFyYXRvcktpdH1cbiAqLyRozY9fb25jZS5jb21wYXJlUmFuayhjb21wYXJlUmFuayk7JGjNj19vbmNlLmNvbXBhcmVBbnRpUmFuayhjb21wYXJlQW50aVJhbmspO1xuY29uc3QgICAgICAgIG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0PShsb25nTGl2ZWQ9ZmFsc2UpPT57XG5sZXQgbnVtU2Vlbj0wO1xuLyogV2hlbiBkeW5hbWljYWxseSBjcmVhdGVkIHdpdGggc2hvcnQgbGlmZXRpbWVzICh0aGUgZGVmYXVsdCkgYSBXZWFrTWFwKi9cbi8qIHdvdWxkIHBlcmZvcm0gcG9vcmx5LCBhbmQgdGhlIGxlYWsgY3JlYXRlZCBieSBhIE1hcCBvbmx5IGxhc3RzIGFzIGxvbmcqL1xuLyogYXMgdGhlIE1hcC4qL1xuY29uc3QgTWFwQ29uc3RydWN0b3I9bG9uZ0xpdmVkP1dlYWtNYXA6TWFwO1xuY29uc3Qgc2Vlbj1uZXcgTWFwQ29uc3RydWN0b3IoKTtcbmNvbnN0IHRhZz0ocik9PntcbmlmKHNlZW4uaGFzKHIpKXtcbnJldHVybiBzZWVuLmdldChyKTtcbiB9XG5udW1TZWVuKz0xO1xuc2Vlbi5zZXQocixudW1TZWVuKTtcbnJldHVybiBudW1TZWVuO1xuIH07XG5jb25zdCBjb21wYXJlUmVtb3RhYmxlcz0oeCx5KT0+Y29tcGFyZVJhbmsodGFnKHgpLHRhZyh5KSk7XG5yZXR1cm4gbWFrZUNvbXBhcmF0b3JLaXQoY29tcGFyZVJlbW90YWJsZXMpO1xuIH07JGjNj19vbmNlLm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KTtcbmhhcmRlbihtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cml2aWFsQ29tcGFyYXRvciI6WyJ0cml2aWFsQ29tcGFyYXRvciJdLCJnZXRQYXNzU3R5bGVDb3ZlciI6WyJnZXRQYXNzU3R5bGVDb3ZlciJdLCJtYWtlQ29tcGFyYXRvcktpdCI6WyJtYWtlQ29tcGFyYXRvcktpdCJdLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiOlsiY29tcGFyYXRvck1pcnJvckltYWdlIl0sImlzUmFua1NvcnRlZCI6WyJpc1JhbmtTb3J0ZWQiXSwiYXNzZXJ0UmFua1NvcnRlZCI6WyJhc3NlcnRSYW5rU29ydGVkIl0sInNvcnRCeVJhbmsiOlsic29ydEJ5UmFuayJdLCJnZXRJbmRleENvdmVyIjpbImdldEluZGV4Q292ZXIiXSwiRnVsbFJhbmtDb3ZlciI6WyJGdWxsUmFua0NvdmVyIl0sImNvdmVyZWRFbnRyaWVzIjpbImNvdmVyZWRFbnRyaWVzIl0sInVuaW9uUmFua0NvdmVycyI6WyJ1bmlvblJhbmtDb3ZlcnMiXSwiaW50ZXJzZWN0UmFua0NvdmVycyI6WyJpbnRlcnNlY3RSYW5rQ292ZXJzIl0sImNvbXBhcmVSYW5rIjpbImNvbXBhcmVSYW5rIl0sImNvbXBhcmVBbnRpUmFuayI6WyJjb21wYXJlQW50aVJhbmsiXSwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiOlsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAai91qtYLAADWCwAAHgAAAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiTmF0IiwiaXNOYXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc05hdCwgJ25hbWUnLCB7dmFsdWU6IFwiaXNOYXRcIn0pOyRozY9fb25jZS5pc05hdChpc05hdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KE5hdCwgJ25hbWUnLCB7dmFsdWU6IFwiTmF0XCJ9KTskaM2PX29uY2UuTmF0KE5hdCk7ICAgLyogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuKi9cbi8qIENvcHlyaWdodCAoQykgMjAxOCBBZ29yaWMqL1xuLyoqL1xuLyogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTsqL1xuLyogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLiovXG4vKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQqL1xuLyoqL1xuLyogaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKi9cbi8qKi9cbi8qIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUqL1xuLyogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLCovXG4vKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4qL1xuLyogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCovXG4vKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4qL1xuXG4vKiBAdHMtY2hlY2sqL1xuXG4vKipcbiAqIElzIGBhbGxlZ2VkTnVtYCBhIG51bWJlciBpbiB0aGUgW2NvbnRpZ3VvdXMgcmFuZ2Ugb2YgZXhhY3RseSBhbmRcbiAqIHVuYW1iaWd1b3VzbHlcbiAqIHJlcHJlc2VudGFibGVdKGh0dHBzOi8vZXNkaXNjdXNzLm9yZy90b3BpYy9tb3JlLW51bWVyaWMtY29uc3RhbnRzLXBsZWFzZS1lc3BlY2lhbGx5LWVwc2lsb24jY29udGVudC0xNClcbiAqICBuYXR1cmFsIG51bWJlcnMgKG5vbi1uZWdhdGl2ZSBpbnRlZ2Vycyk/XG4gKlxuICogVG8gcXVhbGlmeSBgYWxsZWdlZE51bWAgbXVzdCBlaXRoZXIgYmUgYVxuICogbm9uLW5lZ2F0aXZlIGBiaWdpbnRgLCBvciBhIG5vbi1uZWdhdGl2ZSBgbnVtYmVyYCByZXByZXNlbnRpbmcgYW4gaW50ZWdlclxuICogd2l0aGluIHJhbmdlIG9mIFtpbnRlZ2VycyBzYWZlbHkgcmVwcmVzZW50YWJsZSBpblxuICogZmxvYXRpbmcgcG9pbnRdKGh0dHBzOi8vdGMzOS5lcy9lY21hMjYyLyNzZWMtbnVtYmVyLmlzc2FmZWludGVnZXIpLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gYWxsZWdlZE51bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmZ1bmN0aW9uIGlzTmF0KGFsbGVnZWROdW0pe1xuaWYodHlwZW9mIGFsbGVnZWROdW09PT0nYmlnaW50Jyl7XG5yZXR1cm4gYWxsZWdlZE51bT49MDtcbiB9XG5pZih0eXBlb2YgYWxsZWdlZE51bSE9PSdudW1iZXInKXtcbnJldHVybiBmYWxzZTtcbiB9XG5cbnJldHVybiBOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSYmYWxsZWdlZE51bT49MDtcbiB9XG5cbi8qKlxuICogSWYgYGFsbGVnZWROdW1iZXJgIHBhc3NlcyB0aGUgYGlzTmF0YCB0ZXN0LCB0aGVuIHJldHVybiBpdCBhcyBhIGJpZ2ludC5cbiAqIE90aGVyd2lzZSB0aHJvdyBhbiBhcHByb3ByaWF0ZSBlcnJvci5cbiAqXG4gKiBJZiBgYWxsZWdlZE51bWAgaXMgbmVpdGhlciBhIGJpZ2ludCBub3IgYSBudW1iZXIsIGBOYXRgIHRocm93cyBhIGBUeXBlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpZiBpdCBpcyBub3QgYSBbc2FmZWx5XG4gKiByZXByZXNlbnRhYmxlXShodHRwczovL2VzZGlzY3Vzcy5vcmcvdG9waWMvbW9yZS1udW1lcmljLWNvbnN0YW50cy1wbGVhc2UtZXNwZWNpYWxseS1lcHNpbG9uI2NvbnRlbnQtMTQpXG4gKiBub24tbmVnYXRpdmUgaW50ZWdlciwgYE5hdGAgdGhyb3dzIGEgYFJhbmdlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpdCBpcyBjb252ZXJ0ZWQgdG8gYSBiaWdpbnQgaWYgbmVjZXNzYXJ5IGFuZCByZXR1cm5lZC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGFsbGVnZWROdW1cbiAqIEByZXR1cm5zIHtiaWdpbnR9XG4gKi9cbmZ1bmN0aW9uIE5hdChhbGxlZ2VkTnVtKXtcbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J2JpZ2ludCcpe1xuaWYoYWxsZWdlZE51bTwwKXtcbnRocm93IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIGFsbGVnZWROdW07XG4gfVxuXG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdudW1iZXInKXtcbmlmKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSl7XG50aHJvdyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBpcyBub3QgYSBzYWZlIGludGVnZXJgKTtcbiB9XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gaXMgbmVnYXRpdmVgKTtcbiB9XG5yZXR1cm4gQmlnSW50KGFsbGVnZWROdW0pO1xuIH1cblxudGhyb3cgVHlwZUVycm9yKFxuIGAke2FsbGVnZWROdW19IGlzIGEgJHt0eXBlb2YgYWxsZWdlZE51bX0gYnV0IG11c3QgYmUgYSBiaWdpbnQgb3IgYSBudW1iZXJgKTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzTmF0IjpbImlzTmF0Il0sIk5hdCI6WyJOYXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoSmqvD8KAAA/CgAAIAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvZXJyb3IuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy9zdHJpbmcuanMiLCIuL3NyYy9wYXNzU3R5bGVPZi5qcyIsIi4vc3JjL21ha2VUYWdnZWQuanMiLCIuL3NyYy9tYWtlLWZhci5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiLCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkZhciIsImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSIsImFzc2VydFdlbGxGb3JtZWRTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiLCJpc09iamVjdCIsImlzT2JqZWN0IiwiaXNQYXNzYWJsZSIsImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtbXCIuL3NyYy9pdGVyLWhlbHBlcnMuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9lcnJvci5qc1wiLCBbXV0sW1wiLi9zcmMvcmVtb3RhYmxlLmpzXCIsIFtdXSxbXCIuL3NyYy9zeW1ib2wuanNcIiwgW11dLFtcIi4vc3JjL3N0cmluZy5qc1wiLCBbXV0sW1wiLi9zcmMvcGFzc1N0eWxlT2YuanNcIiwgW11dLFtcIi4vc3JjL21ha2VUYWdnZWQuanNcIiwgW11dLFtcIi4vc3JjL21ha2UtZmFyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlR3VhcmRzLmpzXCIsIFtdXSxbXCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvaXRlci1oZWxwZXJzLmpzIjpbWyJtYXBJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sWyJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIl1dLCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6W1siUEFTU19TVFlMRSIsIlBBU1NfU1RZTEUiXSxbImlzT2JqZWN0IiwiaXNPYmplY3QiXSxbImFzc2VydENoZWNrZXIiLCJhc3NlcnRDaGVja2VyIl0sWyJnZXRUYWciLCJnZXRUYWciXSxbImhhc093blByb3BlcnR5T2YiLCJoYXNPd25Qcm9wZXJ0eU9mIl1dLCIuL3NyYy9lcnJvci5qcyI6W1siZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImdldEVycm9yQ29uc3RydWN0b3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3N0cmluZy5qcyI6W1siaXNXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sWyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyJdLFsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRQYXNzYWJsZVN0cmluZyJdXSwiLi9zcmMvcGFzc1N0eWxlT2YuanMiOltbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXSxbImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbInRvVGhyb3dhYmxlIiwidG9UaHJvd2FibGUiXV0sIi4vc3JjL21ha2VUYWdnZWQuanMiOltbIm1ha2VUYWdnZWQiLCJtYWtlVGFnZ2VkIl1dLCIuL3NyYy9tYWtlLWZhci5qcyI6W1siUmVtb3RhYmxlIiwiUmVtb3RhYmxlIl0sWyJGYXIiLCJGYXIiXSxbIlRvRmFyRnVuY3Rpb24iLCJUb0ZhckZ1bmN0aW9uIl0sWyJHRVRfTUVUSE9EX05BTUVTIiwiR0VUX01FVEhPRF9OQU1FUyJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAeYB/DAMIAAADCAAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLGFzc2VydENoZWNrZXIsZ2V0T3duRGF0YURlc2NyaXB0b3I7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRozY9fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheSxwcm90b3R5cGU6YXJyYXlQcm90b3R5cGV9PUFycmF5O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0lNUE9SVCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjYW5CZVZhbGlkPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5pc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmY2hlY2soZmFsc2UsWCBgQXJyYXkgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7SU1QT1JUKCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyBnZXQgdG8gZmFpbC4qL1xuY29uc3QgbGVuPS8qKiBAdHlwZSB7bnVtYmVyfSAqL1xuZ2V0T3duRGF0YURlc2NyaXB0b3IoY2FuZGlkYXRlLCdsZW5ndGgnLGZhbHNlLGFzc2VydENoZWNrZXIpLnZhbHVlO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggaW5kZXggcHJvcGVydHkgaXMgb3duL2RhdGEvZW51bWVyYWJsZSovXG4vKiBhbmQgaXRzIGFzc29jaWF0ZWQgdmFsdWUgaXMgcmVjdXJzaXZlbHkgcGFzc2FibGUuKi9cbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSxpLHRydWUsYXNzZXJ0Q2hlY2tlcikudmFsdWUpO1xuXG4gfVxuLyogRXhwZWN0IG9uZSBrZXkgcGVyIGluZGV4IHBsdXMgb25lIGZvciAnbGVuZ3RoJy4qL1xub3duS2V5cyhjYW5kaWRhdGUpLmxlbmd0aD09PWxlbisxfHxcbmFzc2VydC5mYWlsKFggYEFycmF5cyBtdXN0IG5vdCBoYXZlIG5vbi1pbmRleGVzOiAke2NhbmRpZGF0ZX1gLFR5cGVFcnJvcik7XG4gfX0pOyRozY9fb25jZS5Db3B5QXJyYXlIZWxwZXIoQ29weUFycmF5SGVscGVyKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlBcnJheUhlbHBlciI6WyJDb3B5QXJyYXlIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAArHWRoUkKAABJCgAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJDb3B5UmVjb3JkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGFzc2VydENoZWNrZXIsY2FuQmVNZXRob2QsZ2V0T3duRGF0YURlc2NyaXB0b3IsQ1g7JGjNj19pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiZ2V0T3duRGF0YURlc2NyaXB0b3JcIiwgWyRozY9fYSA9PiAoZ2V0T3duRGF0YURlc2NyaXB0b3IgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0UHJvdG90eXBlT2YscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tPYmplY3RQcm90b3R5cGU9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpPT09b2JqZWN0UHJvdG90eXBlfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZWNvcmRzIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7Y2FuZGlkYXRlfWApO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtQcm9wZXJ0eUtleX0ga2V5XG4gKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxrZXksdmFsdWUsY2hlY2s9dW5kZWZpbmVkKT0+e1xucmV0dXJuKFxuKHR5cGVvZiBrZXk9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkmJihcbiFjYW5CZU1ldGhvZCh2YWx1ZSl8fFxuISFjaGVjayYmXG4vKiBUT0RPOiBVcGRhdGUgbWVzc2FnZSBub3cgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIFwiaW1wbGljaXQgUmVtb3RhYmxlXCIuKi9cbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2Fubm90IGNvbnRhaW4gbm9uLWZhciBmdW5jdGlvbnMgYmVjYXVzZSB0aGV5IG1heSBiZSBtZXRob2RzIG9mIGFuIGltcGxpY2l0IFJlbW90YWJsZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfTtcblxuLyoqXG4gKlxuICogQHR5cGUge0lNUE9SVCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5jaGVja09iamVjdFByb3RvdHlwZShjYW5kaWRhdGUsY2hlY2spJiZcbi8qIFJlamVjdCBhbnkgY2FuZGlkYXRlIHdpdGggYSBzeW1ib2wta2V5ZWQgcHJvcGVydHkgb3IgbWV0aG9kLWxpa2UgcHJvcGVydHkqL1xuLyogKHN1Y2ggaW5wdXQgaXMgcG90ZW50aWFsbHkgYSBSZW1vdGFibGUpLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkuZXZlcnkoKGtleSk9PlxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLGtleSxjYW5kaWRhdGVba2V5XSxjaGVjaykpKTtcblxuXG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2hlY2tPYmplY3RQcm90b3R5cGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggb3duIHByb3BlcnR5IGlzIGFwcHJvcHJpYXRlLCBkYXRhL2VudW1lcmFibGUsKi9cbi8qIGFuZCBoYXMgYSByZWN1cnNpdmVseSBwYXNzYWJsZSBhc3NvY2lhdGVkIHZhbHVlLiovXG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY29uc3R7dmFsdWV9PWdldE93bkRhdGFEZXNjcmlwdG9yKFxuY2FuZGlkYXRlLFxubmFtZSxcbnRydWUsXG5hc3NlcnRDaGVja2VyKTtcblxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLG5hbWUsdmFsdWUsYXNzZXJ0Q2hlY2tlcik7XG5wYXNzU3R5bGVPZlJlY3VyKHZhbHVlKTtcbiB9XG4gfX0pOyRozY9fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weVJlY29yZEhlbHBlciI6WyJDb3B5UmVjb3JkSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9wcm9taXNlLWtpdCIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIiwiLi9tYWtlVGFnZ2VkLmpzIl0sImV4cG9ydHMiOlsiZGVlcGx5RnVsZmlsbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IFgscSxFLGlzUHJvbWlzZSxnZXRUYWcsaXNPYmplY3QscGFzc1N0eWxlT2YsbWFrZVRhZ2dlZDskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRozY9fYSA9PiAoRSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJpc09iamVjdFwiLCBbJGjNj19hID0+IChpc09iamVjdCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dXV0sW1wiLi9tYWtlVGFnZ2VkLmpzXCIsIFtbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUHJpbWl0aXZlLCBDb3B5UmVjb3JkLCBDb3B5QXJyYXksIENvcHlUYWdnZWQsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSdcbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7ZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7eyBbS2V5VHlwZSBpbiBrZXlvZiBUXTogVFtLZXlUeXBlXSB9ICYge319IFNpbXBsaWZ5IGZsYXR0ZW4gdGhlXG4gKiAgIHR5cGUgb3V0cHV0IHRvIGltcHJvdmUgdHlwZSBoaW50cyBzaG93biBpbiBlZGl0b3JzXG4gKiAgIGh0dHBzOi8vZ2l0aHViLmNvbS9zaW5kcmVzb3JodXMvdHlwZS1mZXN0L2Jsb2IvbWFpbi9zb3VyY2Uvc2ltcGxpZnkuZC50c1xuICovXG5cbi8qKlxuICogQ3VycmVudGx5IGNvcGllZCBmcm9tIEBhZ29yaWMvaW50ZXJuYWwgdXRpbHMuanMuXG4gKiBUT0RPIFNob3VsZCBtaWdyYXRlIGhlcmUgYW5kIHRoZW4sIGlmIG5lZWRlZCwgcmVleHBvcnRlZCB0aGVyZS5cbiAqXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IENhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtLIGluIGtleW9mIFRdOiBUW0tdIGV4dGVuZHMgQ2FsbGFibGUgPyBUW0tdIDogRGVlcGx5QXdhaXRlZDxUW0tdPjtcbiAqIH19IERlZXBseUF3YWl0ZWRPYmplY3RcbiAqL1xuXG4vKipcbiAqIEN1cnJlbnRseSBjb3BpZWQgZnJvbSBAYWdvcmljL2ludGVybmFsIHV0aWxzLmpzLlxuICogVE9ETyBTaG91bGQgbWlncmF0ZSBoZXJlIGFuZCB0aGVuLCBpZiBuZWVkZWQsIHJlZXhwb3J0ZWQgdGhlcmUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgUHJvbWlzZUxpa2U8YW55PlxuICogICAgID8gQXdhaXRlZDxUPlxuICogICAgIDogVCBleHRlbmRzIHt9XG4gKiAgICAgICA/IFNpbXBsaWZ5PERlZXBseUF3YWl0ZWRPYmplY3Q8VD4+XG4gKiAgICAgICA6IEF3YWl0ZWQ8VD59IERlZXBseUF3YWl0ZWRcbiAqL1xuXG4vKipcbiAqIEdpdmVuIGEgUGFzc2FibGUgYHZhbGAgd2hvc2UgcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBtYXkgY29udGFpbiBsZWFmXG4gKiBwcm9taXNlcywgcmV0dXJuIGEgcHJvbWlzZSBmb3IgYSByZXBsYWNlbWVudCBQYXNzYWJsZSxcbiAqIHdoZXJlIHRoYXQgcmVwbGFjZW1lbnQgaXMgKmRlZXBseSBmdWxmaWxsZWQqLCBpLmUuLCBpdHNcbiAqIHBhc3MtYnktY29weSBzdHJ1Y3R1cmUgZG9lcyBub3QgY29udGFpbiBhbnkgcHJvbWlzZXMuXG4gKlxuICogVGhpcyBpcyBhIGRlZXAgZm9ybSBvZiBgUHJvbWlzZS5hbGxgIHNwZWNpYWxpemVkIGZvciBQYXNzYWJsZXMuIEZvciBlYWNoXG4gKiBlbmNvdW50ZXJlZCBwcm9taXNlLCByZXBsYWNlIGl0IHdpdGggdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybSBvZlxuICogaXRzIGZ1bGZpbGxtZW50LlxuICogSWYgYW55IG9mIHRoZSBwcm9taXNlcyByZWplY3QsIHRoZW4gdGhlIHByb21pc2UgZm9yIHRoZSByZXBsYWNlbWVudFxuICogcmVqZWN0cy4gSWYgYW55IG9mIHRoZSBwcm9taXNlcyBuZXZlciBzZXR0bGUsIHRoZW4gdGhlIHByb21pc2UgZm9yXG4gKiB0aGUgcmVwbGFjZW1lbnQgbmV2ZXIgc2V0dGxlcy5cbiAqXG4gKiBJZiB0aGUgcmVwbGFjZW1lbnQgd291bGQgbm90IGJlIFBhc3NhYmxlLCBpLmUuLCBpZiBgdmFsYCBpcyBub3RcbiAqIFBhc3NhYmxlLCBvciBpZiBhbnkgb2YgdGhlIHRyYW5zaXRpdmUgcHJvbWlzZXMgZnVsZmlsbCB0byBzb21ldGhpbmdcbiAqIHRoYXQgaXMgbm90IFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBwcm9taXNlIHJlamVjdHMuXG4gKlxuICogSWYgYHZhbGAgb3IgaXRzIHBhcnRzIGFyZSBub24ta2V5IFBhc3NhYmxlcyBvbmx5ICpiZWNhdXNlKiB0aGV5IGNvbnRhaW5cbiAqIHByb21pc2VzLCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtcyBvZiB2YWwgb3IgaXRzIHBhcnRzIG1heSBiZSBrZXlzLiBUaGlzXG4gKiBpcyBmb3IgdGhlIGhpZ2hlciBcIkBlbmRvL3BhdHRlcm5zXCIgbGV2ZWwgb2YgYWJzdHJhY3Rpb24gdG8gZGV0ZXJtaW5lLFxuICogYmVjYXVzZSBpdCBkZWZpbmVzIHRoZSBgS2V5YCBub3Rpb24gaW4gcXVlc3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Q9UGFzc2FibGVdXG4gKiBAcGFyYW0ge1R9IHZhbFxuICogQHJldHVybnMge1Byb21pc2U8RGVlcGx5QXdhaXRlZDxUPj59XG4gKi9cbmNvbnN0ICAgICAgICBkZWVwbHlGdWxmaWxsZWQ9YXN5bmModmFsKT0+e1xuLyogVE9ETyBGaWd1cmUgb3V0IHdoeSB3ZSBuZWVkIHRoZXNlIGF0LWV4cGVjdC1lcnJvciBkaXJlY3RpdmVzIGJlbG93Ki9cbi8qIGFuZCBmaXggaWYgcG9zc2libGUuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTI1NyBtYXkgYmUgcmVsZXZhbnQuKi9cblxuaWYoIWlzT2JqZWN0KHZhbCkpe1xucmV0dXJuICgvKiogQHR5cGUge0RlZXBseUF3YWl0ZWQ8VD59ICovdmFsKTtcbiB9XG5pZihpc1Byb21pc2UodmFsKSl7XG5yZXR1cm4gRS53aGVuKHZhbCwobm9ucCk9PmRlZXBseUZ1bGZpbGxlZChub25wKSk7XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbCk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnY29weVJlY29yZCc6e1xuY29uc3QgcmVjPS8qKiBAdHlwZSB7Q29weVJlY29yZH0gKi92YWw7XG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjKTtcbmNvbnN0IHZhbFBzPW5hbWVzLm1hcCgobmFtZSk9PmRlZXBseUZ1bGZpbGxlZChyZWNbbmFtZV0pKTtcbi8qIEB0cy1leHBlY3QtZXJyb3Igbm90IGFzc2lnbmFibGUgdG8gdHlwZSAnRGVlcGx5QXdhaXRlZDxUPicqL1xucmV0dXJuIEUud2hlbihQcm9taXNlLmFsbCh2YWxQcyksKHZhbHMpPT5cbmhhcmRlbihmcm9tRW50cmllcyh2YWxzLm1hcCgoYyxpKT0+W25hbWVzW2ldLGNdKSkpKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5jb25zdCBhcnI9LyoqIEB0eXBlIHtDb3B5QXJyYXl9ICovdmFsO1xuY29uc3QgdmFsUHM9YXJyLm1hcCgocCk9PmRlZXBseUZ1bGZpbGxlZChwKSk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oUHJvbWlzZS5hbGwodmFsUHMpLCh2YWxzKT0+aGFyZGVuKHZhbHMpKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGdkPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi92YWw7XG5jb25zdCB0YWc9Z2V0VGFnKHRnZCk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oZGVlcGx5RnVsZmlsbGVkKHRnZC5wYXlsb2FkKSwocGF5bG9hZCk9PlxubWFrZVRhZ2dlZCh0YWcscGF5bG9hZCkpO1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IHJlbT0vKiogQHR5cGUge1JlbW90YWJsZU9iamVjdH0gKi92YWw7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiByZW07XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZXJyPS8qKiBAdHlwZSB7RXJyb3J9ICovdmFsO1xuLyogQHRzLWV4cGVjdC1lcnJvciBub3QgYXNzaWduYWJsZSB0byB0eXBlICdEZWVwbHlBd2FpdGVkPFQ+JyovXG5yZXR1cm4gZXJyO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcHJvbT0vKiogQHR5cGUge1Byb21pc2V9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi92YWw7XG5yZXR1cm4gRS53aGVuKHByb20sKG5vbnApPT5kZWVwbHlGdWxmaWxsZWQobm9ucCkpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoWCBgVW5leHBlY3RlZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9YCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9OyRozY9fb25jZS5kZWVwbHlGdWxmaWxsZWQoZGVlcGx5RnVsZmlsbGVkKTtcbmhhcmRlbihkZWVwbHlGdWxmaWxsZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVlcGx5RnVsZmlsbGVkIjpbImRlZXBseUZ1bGZpbGxlZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABREv3gLhsAAC4bAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yIiwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiLCJnZXRFcnJvckNvbnN0cnVjdG9yIiwiaXNFcnJvckxpa2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcSxhc3NlcnRDaGVja2VyLENYOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlSGVscGVyfSBmcm9tICcuL2ludGVybmFsLXR5cGVzLmpzJyAqL1xuLyoqIEBpbXBvcnQge0NoZWNrZXIsIFBhc3NTdHlsZSwgUGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsaGFzT3duLGVudHJpZXN9PU9iamVjdDtcblxuLyogVE9ETzogTWFpbnRlbmFuY2UgaGF6YXJkOiBDb29yZGluYXRlIHdpdGggdGhlIGxpc3Qgb2YgZXJyb3JzIGluIHRoZSBTRVMqL1xuLyogd2hpbGVsaXN0LiovXG5jb25zdCBlcnJvckNvbnN0cnVjdG9ycz1uZXcgTWFwKFxuLyogQ2FzdCBiZWNhdXNlIG90aGVyd2lzZSBUUyBpcyBjb25mdXNlZCBieSBBZ2dyZWdhdGVFcnJvciovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMjA0MiNkaXNjdXNzaW9uX3IxNDg0OTMzMDI4Ki9cbi8qKiBAdHlwZSB7QXJyYXk8W3N0cmluZywgSU1QT1JUKCdzZXMnKS5HZW5lcmljRXJyb3JDb25zdHJ1Y3Rvcl0+fSAqL1xuW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1cblxuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy81NTAqL1xuLyogVG8gYWNjb21tb2RhdGUgcGxhdGZvcm1zIHByaW9yIHRvIEFnZ3JlZ2F0ZUVycm9yLCB3ZSBjb21tZW50IG91dCB0aGUqL1xuLyogZm9sbG93aW5nIGxpbmUgYW5kIGluc3RlYWQgY29uZGl0aW9uYWxseSBhZGQgaXQgdG8gdGhlIG1hcCBiZWxvdy4qL1xuLyogWydBZ2dyZWdhdGVFcnJvcicsIEFnZ3JlZ2F0ZUVycm9yXSwqL10pO1xuXG5cblxuaWYodHlwZW9mIEFnZ3JlZ2F0ZUVycm9yIT09J3VuZGVmaW5lZCcpe1xuLyogQ29uZGl0aW9uYWwsIHRvIGFjY29tbW9kYXRlIHBsYXRmb3JtcyBwcmlvciB0byBBZ2dyZWdhdGVFcnJvciovXG5lcnJvckNvbnN0cnVjdG9ycy5zZXQoJ0FnZ3JlZ2F0ZUVycm9yJyxBZ2dyZWdhdGVFcnJvcik7XG4gfVxuXG4vKipcbiAqIEJlY2F1c2UgdGhlIGVycm9yIGNvbnN0cnVjdG9yIHJldHVybmVkIGJ5IHRoaXMgZnVuY3Rpb24gbWlnaHQgYmVcbiAqIGBBZ2dyZWdhdGVFcnJvcmAsIHdoaWNoIGhhcyBkaWZmZXJlbnQgY29uc3RydWN0aW9uIHBhcmFtZXRlcnNcbiAqIGZyb20gdGhlIG90aGVyIGVycm9yIGNvbnN0cnVjdG9ycywgZG8gbm90IHVzZSBpdCBkaXJlY3RseSB0byB0cnlcbiAqIHRvIG1ha2UgYW4gZXJyb3IgaW5zdGFuY2UuIFJhdGhlciwgdXNlIGBtYWtlRXJyb3JgIHdoaWNoIGVuY2Fwc3VsYXRlc1xuICogdGhpcyBub24tdW5pZm9ybWl0eS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge0lNUE9SVCgnc2VzJykuR2VuZXJpY0Vycm9yQ29uc3RydWN0b3IgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRFcnJvckNvbnN0cnVjdG9yPShuYW1lKT0+ZXJyb3JDb25zdHJ1Y3RvcnMuZ2V0KG5hbWUpOyRozY9fb25jZS5nZXRFcnJvckNvbnN0cnVjdG9yKGdldEVycm9yQ29uc3RydWN0b3IpO1xuaGFyZGVuKGdldEVycm9yQ29uc3RydWN0b3IpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja0Vycm9yTGlrZT0oY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9Pntcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxuISFjaGVjayYmQ1goY2hlY2spIGBFcnJvciBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbiB9O1xuaGFyZGVuKGNoZWNrRXJyb3JMaWtlKTtcbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogVmFsaWRhdGluZyBlcnJvciBvYmplY3RzIGFyZSBwYXNzYWJsZSByYWlzZXMgYSB0ZW5zaW9uIGJldHdlZW4gc2VjdXJpdHlcbiAqIHZzIHByZXNlcnZpbmcgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gRm9yIGVycm9ycywgd2UgbmVlZCB0byByZW1lbWJlclxuICogdGhlIGVycm9yIGl0c2VsZiBleGlzdHMgdG8gaGVscCB1cyBkaWFnbm9zZSBhIGJ1ZyB0aGF0J3MgbGlrZWx5IG1vcmVcbiAqIHByZXNzaW5nIHRoYW4gYSB2YWxpZGl0eSBidWcgaW4gdGhlIGVycm9yIGl0c2VsZi4gVGh1cywgd2hlbmV2ZXIgaXQgaXMgc2FmZVxuICogdG8gZG8gc28sIHdlIHByZWZlciB0byBsZXQgdGhlIGVycm9yLWxpa2UgdGVzdCBzdWNjZWVkIGFuZCB0byBjb3VjaCB0aGVzZVxuICogY29tcGxhaW50cyBhcyBub3RlcyBvbiB0aGUgZXJyb3IuXG4gKlxuICogVG8gcmVzb2x2ZSB0aGlzLCBzdWNoIGEgbWFsZm9ybWVkIGVycm9yIG9iamVjdCB3aWxsIHN0aWxsIHBhc3NcbiAqIGBpc0Vycm9yTGlrZWAgc28gbWFyc2hhbCBjYW4gdXNlIHRoaXMgZm9yIHRvcCBsZXZlbCBlcnJvciB0byByZXBvcnQgZnJvbSxcbiAqIGV2ZW4gaWYgaXQgd291bGQgbm90IGFjdHVhbGx5IHZhbGlkYXRlLlxuICogSW5zdGVhZCwgdGhlIGRpYWdub3N0aWNzIHRoYXQgYGFzc2VydEVycm9yYCB3b3VsZCBoYXZlIHJlcG9ydGVkIGFyZVxuICogYXR0YWNoZWQgYXMgbm90ZXMgdG8gdGhlIG1hbGZvcm1lZCBlcnJvci4gVGh1cywgYSBtYWxmb3JtZWRcbiAqIGVycm9yIGlzIHBhc3NhYmxlIGJ5IGl0c2VsZiwgYnV0IG5vdCBhcyBwYXJ0IG9mIGEgcGFzc2FibGUgc3RydWN0dXJlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzRXJyb3JMaWtlPShjYW5kaWRhdGUpPT5jaGVja0Vycm9yTGlrZShjYW5kaWRhdGUpOyRozY9fb25jZS5pc0Vycm9yTGlrZShpc0Vycm9yTGlrZSk7XG5oYXJkZW4oaXNFcnJvckxpa2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBwcm9wTmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEBwYXJhbSB7KHZhbDogYW55KSA9PiBQYXNzU3R5bGV9IHBhc3NTdHlsZU9mUmVjdXJcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYz0oXG5wcm9wTmFtZSxcbmRlc2MsXG5wYXNzU3R5bGVPZlJlY3VyLFxuY2hlY2s9dW5kZWZpbmVkKT0+XG57XG5pZihkZXNjLmVudW1lcmFibGUpe1xucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yICR7cShcbnByb3BOYW1lKVxuIH0gb3duIHByb3BlcnR5IG11c3Qgbm90IGJlIGVudW1lcmFibGU6ICR7ZGVzY31gKTtcblxuIH1cbmlmKCFoYXNPd24oZGVzYywndmFsdWUnKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGRhdGEgcHJvcGVydHk6ICR7ZGVzY31gKTtcblxuIH1cbmNvbnN0e3ZhbHVlfT1kZXNjO1xuc3dpdGNoKHByb3BOYW1lKXtcbmNhc2UnbWVzc2FnZSc6XG5jYXNlJ3N0YWNrJzp7XG5yZXR1cm4oXG50eXBlb2YgdmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt2YWx1ZX1gKTtcblxuIH1cbmNhc2UnY2F1c2UnOntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IodmFsdWUscGFzc1N0eWxlT2ZSZWN1cixjaGVjayk7XG4gfVxuY2FzZSdlcnJvcnMnOntcbmlmKCFBcnJheS5pc0FycmF5KHZhbHVlKXx8cGFzc1N0eWxlT2ZSZWN1cih2YWx1ZSkhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGNvcHlBcnJheTogJHt2YWx1ZX1gKTtcblxuIH1cbnJldHVybiB2YWx1ZS5ldmVyeSgoZXJyKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mUmVjdXIsY2hlY2spKTtcblxuIH1cbmRlZmF1bHQ6e1xuYnJlYWs7XG4gfX1cblxucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yIGhhcyBleHRyYSB1bnBhc3NlZCBwcm9wZXJ0eSAke3EocHJvcE5hbWUpfWApO1xuXG4gfTskaM2PX29uY2UuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MpO1xuaGFyZGVuKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHsodmFsOiBhbnkpID0+IFBhc3NTdHlsZX0gcGFzc1N0eWxlT2ZSZWN1clxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yPShcbmNhbmRpZGF0ZSxcbnBhc3NTdHlsZU9mUmVjdXIsXG5jaGVjaz11bmRlZmluZWQpPT5cbntcbmlmKCFjaGVja0Vycm9yTGlrZShjYW5kaWRhdGUsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpO1xuY29uc3R7bmFtZX09cHJvdG87XG5jb25zdCBlcnJDb25zdHJ1Y3Rvcj1nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpO1xuaWYoZXJyQ29uc3RydWN0b3I9PT11bmRlZmluZWR8fGVyckNvbnN0cnVjdG9yLnByb3RvdHlwZSE9PXByb3RvKXtcbnJldHVybihcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgUGFzc2FibGUgRXJyb3IgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCk7XG5cbiB9XG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZighKCdtZXNzYWdlJ2luIGRlc2NzKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFBhc3NhYmxlIEVycm9yIG11c3QgaGF2ZSBhbiBvd24gXCJtZXNzYWdlXCIgc3RyaW5nIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTtcblxuIH1cblxucmV0dXJuIGVudHJpZXMoZGVzY3MpLmV2ZXJ5KChbcHJvcE5hbWUsZGVzY10pPT5cbmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKFxucHJvcE5hbWUsXG5kZXNjLFxucGFzc1N0eWxlT2ZSZWN1cixcbmNoZWNrKSk7XG5cblxuIH07JGjNj19vbmNlLmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKTtcbmhhcmRlbihjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcik7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+XG5jaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cixhc3NlcnRDaGVja2VyKX0pOyRozY9fb25jZS5FcnJvckhlbHBlcihFcnJvckhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAu5h1k2cIAABnCAAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiLi9tYWtlLWZhci5qcyJdLCJleHBvcnRzIjpbImZpbHRlckl0ZXJhYmxlIiwibWFwSXRlcmFibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgRmFyOyRozY9faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaM2PX2EgPT4gKEZhciA9ICRozY9fYSldXV1dXSk7ICAgXG5cbi8qKlxuICogVGhlIHJlc3VsdCBpdGVyYXRvciBoYXMgYXMgbWFueSBlbGVtZW50cyBhcyB0aGUgYGJhc2VJdGVyYXRvcmAgYW5kXG4gKiBoYXZlIHRoZSBzYW1lIHRlcm1pbmF0aW9uIC0tIHRoZSBzYW1lIGNvbXBsZXRpb24gdmFsdWUgb3IgZmFpbHVyZVxuICogcmVhc29uLiBCdXQgdGhlIG5vbi1maW5hbCB2YWx1ZXMgYXJlIHRoZSBjb3JyZXNwb25kaW5nIG5vbi1maW5hbFxuICogdmFsdWVzIGZyb20gYGJhc2VJdGVyYXRvcmAgYXMgdHJhbnNmb3JtZWQgYnkgYGZ1bmNgLlxuICpcbiAqIEB0ZW1wbGF0ZSBULFVcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IGJhc2VJdGVyYWJsZVxuICogQHBhcmFtIHsodmFsdWU6IFQpID0+IFV9IGZ1bmNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxVPn1cbiAqL1xuY29uc3QgICAgICAgIG1hcEl0ZXJhYmxlPShiYXNlSXRlcmFibGUsZnVuYyk9PlxuLyoqIEB0eXBlIHtJdGVyYWJsZTxVPn0gKi9cbkZhcignbWFwcGVkIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgYmFzZUl0ZXJhdG9yPWJhc2VJdGVyYWJsZVtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gRmFyKCdtYXBwZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmNvbnN0e3ZhbHVlOmJhc2VWYWx1ZSxkb25lfT1iYXNlSXRlcmF0b3IubmV4dCgpO1xuY29uc3QgdmFsdWU9ZG9uZT9iYXNlVmFsdWU6ZnVuYyhiYXNlVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7dmFsdWUsZG9uZX0pO1xuIH19KTtcblxuIH19KTskaM2PX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjNj19vbmNlLmZpbHRlckl0ZXJhYmxlKGZpbHRlckl0ZXJhYmxlKTtcblxuaGFyZGVuKGZpbHRlckl0ZXJhYmxlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1hcEl0ZXJhYmxlIjpbIm1hcEl0ZXJhYmxlIl0sImZpbHRlckl0ZXJhYmxlIjpbImZpbHRlckl0ZXJhYmxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN5jxppcJAAAXCQAACcAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZS1mYXIuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyIsIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3JlbW90YWJsZS5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkdFVF9NRVRIT0RfTkFNRVMiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldE1ldGhvZE5hbWVzLHEsRmFpbCxhc3NlcnRDaGVja2VyLFBBU1NfU1RZTEUsYXNzZXJ0SWZhY2UsZ2V0SW50ZXJmYWNlT2YsUmVtb3RhYmxlSGVscGVyOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qc1wiLCBbW1wiZ2V0TWV0aG9kTmFtZXNcIiwgWyRozY9fYSA9PiAoZ2V0TWV0aG9kTmFtZXMgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcImFzc2VydElmYWNlXCIsIFskaM2PX2EgPT4gKGFzc2VydElmYWNlID0gJGjNj19hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaM2PX2EgPT4gKGdldEludGVyZmFjZU9mID0gJGjNj19hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge1JlbW90YWJsZUJyYW5kfSBmcm9tICdAZW5kby9ldmVudHVhbC1zZW5kJyAqL1xuLyoqIEBpbXBvcnQge0ludGVyZmFjZVNwZWMsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuY29uc3R7cHJvdG90eXBlOmZ1bmN0aW9uUHJvdG90eXBlfT1GdW5jdGlvbjtcbmNvbnN0e1xuZ2V0UHJvdG90eXBlT2YsXG5zZXRQcm90b3R5cGVPZixcbmNyZWF0ZSxcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09XG5PYmplY3Q7XG5cbi8qKlxuICogTm93IHRoYXQgdGhlIHJlbW90YWJsZVByb3RvIGRvZXMgbm90IHByb3ZpZGUgaXRzIG93biBgdG9TdHJpbmdgIG1ldGhvZCxcbiAqIGVuc3VyZSBpdCBhbHdheXMgaW5oZXJpdHMgZnJvbSBzb21ldGhpbmcuIFRoZSBvcmlnaW5hbCBwcm90b3R5cGUgb2ZcbiAqIGByZW1vdGFibGVgIGlmIHRoZXJlIHdhcyBvbmUsIG9yIGBPYmplY3QucHJvdG90eXBlYCBvdGhlcndpc2UuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IHJlbW90YWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHJldHVybnMge29iamVjdH1cbiAqL1xuY29uc3QgbWFrZVJlbW90YWJsZVByb3RvPShyZW1vdGFibGUsaWZhY2UpPT57XG5sZXQgb2xkUHJvdG89Z2V0UHJvdG90eXBlT2YocmVtb3RhYmxlKTtcbmlmKHR5cGVvZiByZW1vdGFibGU9PT0nb2JqZWN0Jyl7XG5pZihvbGRQcm90bz09PW51bGwpe1xub2xkUHJvdG89b2JqZWN0UHJvdG90eXBlO1xuIH1cbm9sZFByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbkZhaWwgYEZvciBub3csIHJlbW90YWJsZXMgY2Fubm90IGluaGVyaXQgZnJvbSBhbnl0aGluZyB1bnVzdWFsLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNlIGlmKHR5cGVvZiByZW1vdGFibGU9PT0nZnVuY3Rpb24nKXtcbm9sZFByb3RvIT09bnVsbHx8XG5GYWlsIGBPcmlnaW5hbCBmdW5jdGlvbiBtdXN0IG5vdCBpbmhlcml0IGZyb20gbnVsbDogJHtyZW1vdGFibGV9YDtcbm9sZFByb3RvPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuZ2V0UHJvdG90eXBlT2Yob2xkUHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuRmFpbCBgRmFyIGZ1bmN0aW9ucyBtdXN0IG9yaWdpbmFsbHkgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZSwgaW4gJHtyZW1vdGFibGV9YDtcbiB9ZWxzZXtcbkZhaWwgYHVucmVjb2duaXplZCB0eXBlb2YgJHtyZW1vdGFibGV9YDtcbiB9XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9sZFByb3RvLHtcbltQQVNTX1NUWUxFXTp7dmFsdWU6J3JlbW90YWJsZSd9LFxuW1N5bWJvbC50b1N0cmluZ1RhZ106e3ZhbHVlOmlmYWNlfX0pKTtcblxuXG4gfTtcblxuY29uc3QgYXNzZXJ0Q2FuQmVSZW1vdGFibGU9KGNhbmRpZGF0ZSk9PlxuUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENyZWF0ZSBhbmQgcmVnaXN0ZXIgYSBSZW1vdGFibGUuICBBZnRlciB0aGlzLCBnZXRJbnRlcmZhY2VPZihyZW1vdGFibGUpXG4gKiByZXR1cm5zIGlmYWNlLlxuICpcbiAqIC8vIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvODA0XG4gKlxuICogQHRlbXBsYXRlIHt7fX0gVFxuICogQHRlbXBsYXRlIHtJbnRlcmZhY2VTcGVjfSBJXG4gKiBAcGFyYW0ge0l9IFtpZmFjZV0gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHNdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlT2JqZWN0PEk+ICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fX0gcmVtb3RhYmxlLCBtb2RpZmllZCBmb3IgZGVidWdnYWJpbGl0eVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlPShcbi8qIEB0cy1leHBlY3QtZXJyb3IgSSBjb3VsZCBoYXZlIGRpZmZlcmVudCBzdWJ0eXBlIHRoYW4gc3RyaW5nKi9cbmlmYWNlPSdSZW1vdGFibGUnLFxucHJvcHM9dW5kZWZpbmVkLFxucmVtb3RhYmxlPS8qKiBAdHlwZSB7VH0gKi97fSk9Plxue1xuYXNzZXJ0SWZhY2UoaWZhY2UpO1xuYXNzZXJ0KGlmYWNlKTtcbi8qIFRPRE86IFdoZW4gaWZhY2UgaXMgcmljaGVyIHRoYW4ganVzdCBzdHJpbmcsIHdlIG5lZWQgdG8gZ2V0IHRoZSBhbGxlZ2VkTmFtZSovXG4vKiBpbiBhIGRpZmZlcmVudCB3YXkuKi9cbnByb3BzPT09dW5kZWZpbmVkfHxGYWlsIGBSZW1vdGFibGUgcHJvcHMgbm90IHlldCBpbXBsZW1lbnRlZCAke3Byb3BzfWA7XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgdGhhdCB0aGUgdW5tb2RpZmllZCBvYmplY3QgaXMgYWJsZSB0byBiZWNvbWUgYSBSZW1vdGFibGUuKi9cbmFzc2VydENhbkJlUmVtb3RhYmxlKHJlbW90YWJsZSk7XG5cbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBtYXJrZWQuKi9cbiEoUEFTU19TVFlMRSBpbiByZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBtYXJrZWQgYXMgYSAke3EoXG5yZW1vdGFibGVbUEFTU19TVFlMRV0pXG4gfWA7XG4vKiBgaXNGcm96ZW5gIGFsd2F5cyByZXR1cm5zIHRydWUgd2l0aCBhIGZha2UgYGhhcmRlbmAsIGJ1dCB3ZSB3YW50IHRoYXQgY2FzZSovXG4vKiB0byBzdWNjZWVkIGFueXdheS4gRmFraW5nIGBoYXJkZW5gIGlzIG9ubHkgY29ycmVjdG5lc3MgcHJlc2VydmluZyovXG4vKiBpZiB0aGUgY29kZSBpbiBxdWVzdGlvbiBjb250YWlucyBubyBidWdzIHRoYXQgdGhlIHJlYWwgYGhhcmRlbmAgd291bGQqL1xuLyogaGF2ZSBjYXVnaHQuKi9cbi8qIEB0cy1pZ25vcmUgYGlzRmFrZWAgcHVycG9zZWx5IG5vdCBpbiB0aGUgdHlwZSovXG5oYXJkZW4uaXNGYWtlfHxcbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBmcm96ZW4uKi9cbiFpc0Zyb3plbihyZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBmcm96ZW5gO1xuY29uc3QgcmVtb3RhYmxlUHJvdG89bWFrZVJlbW90YWJsZVByb3RvKHJlbW90YWJsZSxpZmFjZSk7XG5cbi8qIFRha2UgYSBzdGF0aWMgY29weSBvZiB0aGUgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBhcyBkYXRhIHByb3BlcnRpZXMuKi9cbi8qIGNvbnN0IHByb3BEZXNjcyA9IGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoeyAuLi5wcm9wcyB9KTsqL1xuY29uc3QgbXV0YXRlSGFyZGVuQW5kQ2hlY2s9KHRhcmdldCk9Pntcbi8qIGRlZmluZVByb3BlcnRpZXModGFyZ2V0LCBwcm9wRGVzY3MpOyovXG5zZXRQcm90b3R5cGVPZih0YXJnZXQscmVtb3RhYmxlUHJvdG8pO1xuaGFyZGVuKHRhcmdldCk7XG5hc3NlcnRDYW5CZVJlbW90YWJsZSh0YXJnZXQpO1xuIH07XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgYSBmcmVzaCByZW1vdGFibGUgdG8gc2VlIGlmIG91ciBydWxlcyBmaXQuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHt9KTtcblxuLyogQWN0dWFsbHkgZmluaXNoIHRoZSBuZXcgcmVtb3RhYmxlLiovXG5tdXRhdGVIYXJkZW5BbmRDaGVjayhyZW1vdGFibGUpO1xuXG4vKiBDT01NSVRURUQhKi9cbi8qIFdlJ3JlIGNvbW1pdHRlZCwgc28ga2VlcCB0aGUgaW50ZXJmYWNlIGZvciBmdXR1cmUgcmVmZXJlbmNlLiovXG5hc3NlcnQoaWZhY2UhPT11bmRlZmluZWQpOy8qIFRvIG1ha2UgVHlwZVNjcmlwdCBoYXBweSovXG5yZXR1cm4gKC8qKiBAdHlwZSB7YW55fSAqL3JlbW90YWJsZSk7XG4gfTskaM2PX29uY2UuUmVtb3RhYmxlKFJlbW90YWJsZSk7XG5oYXJkZW4oUmVtb3RhYmxlKTtcblxuLyoqXG4gKiBUaGUgbmFtZSBvZiB0aGUgYXV0b21hdGljYWxseSBhZGRlZCBkZWZhdWx0IG1ldGEtbWV0aG9kIGZvciBvYnRhaW5pbmcgYVxuICogbGlzdCBvZiBhbGwgbWV0aG9kcyBvZiBhbiBvYmplY3QgZGVjbGFyZWQgd2l0aCBgRmFyYCwgb3IgYW4gb2JqZWN0IHRoYXRcbiAqIGluaGVyaXRzIGZyb20gYW4gb2JqZWN0IGRlY2xhcmVkIHdpdGggYEZhcmAuXG4gKlxuICogTW9kZWxlZCBvbiBgR0VUX0lOVEVSRkFDRV9HVUFSRGAgZnJvbSBgQGVuZG8vZXhvYC5cbiAqXG4gKiBUT0RPIE5hbWUgdG8gYmUgYmlrZXNoZWQuIFBlcmhhcHMgZXZlbiB3aGV0aGVyIGl0IGlzIGFcbiAqIHN0cmluZyBvciBzeW1ib2wgdG8gYmUgYmlrZXNoZWQuIFNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTgwOSNkaXNjdXNzaW9uX3IxMzg4MDUyNDU0XG4gKlxuICogSEFaQVJEOiBCZXdhcmUgdGhhdCBhbiBleG8ncyBpbnRlcmZhY2UgY2FuIGNoYW5nZSBhY3Jvc3MgYW4gdXBncmFkZSxcbiAqIHNvIHJlbW90ZXMgdGhhdCBjYWNoZSBpdCBjYW4gYmVjb21lIHN0YWxlLlxuICovXG5jb25zdCAgICAgICAgR0VUX01FVEhPRF9OQU1FUz0nX19nZXRNZXRob2ROYW1lc19fJztcblxuLyoqXG4gKiBOb3RlIHRoYXQgYGdldE1ldGhvZE5hbWVzTWV0aG9kYCBpcyBhIHRoaXNmdWwgbWV0aG9kISBJdCBtdXN0IGJlIHNvIHRoYXRcbiAqIGl0IHdvcmtzIGFzIGV4cGVjdGVkIHdpdGggZmFyLW9iamVjdCBpbmhlcml0YW5jZS5cbiAqXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi8kaM2PX29uY2UuR0VUX01FVEhPRF9OQU1FUyhHRVRfTUVUSE9EX05BTUVTKTtcbmNvbnN0IGdldE1ldGhvZE5hbWVzTWV0aG9kPWhhcmRlbih7XG5bR0VUX01FVEhPRF9OQU1FU10oKXtcbnJldHVybiBnZXRNZXRob2ROYW1lcyh0aGlzKTtcbiB9fSlbXG5HRVRfTUVUSE9EX05BTUVTXTtcblxuY29uc3QgZ2V0TWV0aG9kTmFtZXNEZXNjcmlwdG9yPWhhcmRlbih7XG52YWx1ZTpnZXRNZXRob2ROYW1lc01ldGhvZCxcbmVudW1lcmFibGU6ZmFsc2UsXG5jb25maWd1cmFibGU6ZmFsc2UsXG53cml0YWJsZTpmYWxzZX0pO1xuXG5cbi8qKlxuICogTWFyayBhbiBvYmplY3QgdG8gYmUgZXhwb3NlZCBmb3IgcmVtb3RlIGludGVyYWN0aW9uXG4gKiBhbmQgZ2l2ZSBpdCBhIHN1Z2dlc3RpdmUgaW50ZXJmYWNlIG5hbWUgZm9yIGRlYnVnZ2luZy5cbiAqXG4gKiBBbGwgcHJvcGVydGllcyBvZiB0aGUgb2JqZWN0IGhhdmUgdG8gYmUgbWV0aG9kcywgbm90IGRhdGEuXG4gKlxuICogVGhlIG9iamVjdCBtdXN0IG5vdCBiZSBoYXJkZW5lZCBiZWZvcmUgaXQgaXMgbWFya2VkLlxuICogSXQgd2lsbCBiZSBoYXJkZW5lZCBhZnRlciBtYXJraW5nLlxuICpcbiAqIEZvciBmYXIgb2JqZWN0cyAoYXMgb3Bwb3NlZCB0byBmYXIgZnVuY3Rpb25zKSwgYWxzbyBhZGRzXG4gKiBgX19nZXRNZXRob2ROYW1lc19fYCBtZXRob2QgdGhhdCByZXR1cm5zIGFuIGFycmF5IG9mIGFsbCB0aGUgbWV0aG9kIG5hbWVzLFxuICogaWYgdGhlcmUgaXMgbm90IHlldCBhbnkgbWV0aG9kIG5hbWVkIGBfX2dldE1ldGhvZE5hbWVzX19gLlxuICpcbiAqIEBleGFtcGxlXG4gKiBGYXIoJ0VtcGxveWVlJywgeyBnZXRNYW5hZ2VyIH0pXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZmFyTmFtZSBUaGlzIG5hbWUgd2lsbCBiZSBwcmVwZW5kZWQgd2l0aCBgQWxsZWdlZDogYFxuICogZm9yIG5vdyB0byBmb3JtIHRoZSBgUmVtb3RhYmxlYCBgaWZhY2VgIGFyZ3VtZW50LlxuICogQHBhcmFtIHtUfSBbcmVtb3RhYmxlXSBUaGUgb2JqZWN0IHRvIGJlIG1hcmtlZCBhcyByZW1vdGFibGVcbiAqL1xuY29uc3QgICAgICAgIEZhcj0oZmFyTmFtZSxyZW1vdGFibGU9dW5kZWZpbmVkKT0+e1xuY29uc3Qgcj1yZW1vdGFibGU9PT11bmRlZmluZWQ/LyoqIEB0eXBlIHtUfSAqL3t9OnJlbW90YWJsZTtcbmlmKHR5cGVvZiByPT09J29iamVjdCcmJiEoR0VUX01FVEhPRF9OQU1FUyBpbiByKSl7XG4vKiBUaGlzIHRlc3QgZXhjbHVkZXMgZmFyIGZ1bmN0aW9ucywgc2luY2Ugd2UgY3VycmVudGx5IGNvbnNpZGVyIHRoZW0qL1xuLyogdG8gb25seSBoYXZlIGEgY2FsbC1iZWhhdmlvciwgd2l0aCBubyBjYWxsYWJsZSBtZXRob2RzLiovXG4vKiBCZXdhcmU6IE11dGF0ZXMgdGhlIGlucHV0IGFyZ3VtZW50ISBCdXQgYFJlbW90YWJsZWAqL1xuLyogKiByZXF1aXJlcyB0aGUgb2JqZWN0IHRvIGJlIG11dGFibGUqL1xuLyogKiBkb2VzIGZ1cnRoZXIgbXV0YXRpb25zLCovXG4vKiAqIGhhcmRlbnMgdGhlIG11dGF0ZWQgb2JqZWN0IGJlZm9yZSByZXR1cm5pbmcgaXQuKi9cbi8qIHNvIHRoaXMgbXV0YXRpb24gaXMgbm90IHVucHJlY2VkZW50ZWQuIEJ1dCBpdCBpcyBzdXJwcmlzaW5nISovXG5PYmplY3QuZGVmaW5lUHJvcGVydHkocixHRVRfTUVUSE9EX05BTUVTLGdldE1ldGhvZE5hbWVzRGVzY3JpcHRvcik7XG4gfVxucmV0dXJuIFJlbW90YWJsZSggYEFsbGVnZWQ6ICR7ZmFyTmFtZX1gLHVuZGVmaW5lZCxyKTtcbiB9OyRozY9fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gRlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0ge0Z9IGZ1bmNcbiAqIEByZXR1cm5zIHtGICYgUmVtb3RhYmxlT2JqZWN0ICYgUmVtb3RhYmxlQnJhbmQ8e30sIEY+fVxuICovXG5jb25zdCAgICAgICAgVG9GYXJGdW5jdGlvbj0oZmFyTmFtZSxmdW5jKT0+e1xuaWYoZ2V0SW50ZXJmYWNlT2YoZnVuYykhPT11bmRlZmluZWQpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjaGVja2VkIGNhc3QqL1xucmV0dXJuIGZ1bmM7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBjb3VsZCBiZSBkaWZmZXJlbnQgc3VidHlwZSovXG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRozY9fb25jZS5Ub0ZhckZ1bmN0aW9uKFRvRmFyRnVuY3Rpb24pO1xuaGFyZGVuKFRvRmFyRnVuY3Rpb24pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUmVtb3RhYmxlIjpbIlJlbW90YWJsZSJdLCJHRVRfTUVUSE9EX05BTUVTIjpbIkdFVF9NRVRIT0RfTkFNRVMiXSwiRmFyIjpbIkZhciJdLCJUb0ZhckZ1bmN0aW9uIjpbIlRvRmFyRnVuY3Rpb24iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGVoiOh4FAAAeBQAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIl0sImV4cG9ydHMiOlsibWFrZVRhZ2dlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLFBBU1NfU1RZTEUsYXNzZXJ0UGFzc2FibGU7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBUXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQXG4gKiBAcGFyYW0ge1R9IHRhZ1xuICogQHBhcmFtIHtQfSBwYXlsb2FkXG4gKiBAcmV0dXJucyB7SU1QT1JUKCcuL3R5cGVzLmpzJykuQ29weVRhZ2dlZDxULFA+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRozY9fb25jZS5tYWtlVGFnZ2VkKG1ha2VUYWdnZWQpO1xuaGFyZGVuKG1ha2VUYWdnZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRhZ2dlZCI6WyJtYWtlVGFnZ2VkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiQ1giLCJQQVNTX1NUWUxFIiwiYXNzZXJ0Q2hlY2tlciIsImNhbkJlTWV0aG9kIiwiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCIsImNoZWNrUGFzc1N0eWxlIiwiY2hlY2tUYWdSZWNvcmQiLCJnZXRPd25EYXRhRGVzY3JpcHRvciIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IsXG5nZXRQcm90b3R5cGVPZixcbmhhc093blByb3BlcnR5Om9iamVjdEhhc093blByb3BlcnR5LFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcbmNvbnN0e2FwcGx5fT1SZWZsZWN0O1xuY29uc3R7dG9TdHJpbmdUYWc6dG9TdHJpbmdUYWdTeW1ib2x9PVN5bWJvbDtcblxuY29uc3QgdHlwZWRBcnJheVByb3RvdHlwZT1nZXRQcm90b3R5cGVPZihVaW50OEFycmF5LnByb3RvdHlwZSk7XG5jb25zdCB0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjPWdldE93blByb3BlcnR5RGVzY3JpcHRvcihcbnR5cGVkQXJyYXlQcm90b3R5cGUsXG50b1N0cmluZ1RhZ1N5bWJvbCk7XG5cbmFzc2VydCh0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjKTtcbmNvbnN0IGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZz10eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjLmdldDtcbmFzc2VydCh0eXBlb2YgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPT09J2Z1bmN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBoYXNPd25Qcm9wZXJ0eU9mPShvYmoscHJvcCk9PlxuYXBwbHkob2JqZWN0SGFzT3duUHJvcGVydHksb2JqLFtwcm9wXSk7JGjNj19vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbi8qIFRPRE8gdHJ5IHR5cGluZyB0aGlzOyBgPT4gdmFsIGlzIHt9IHRvbyBuYXJyb3csIGltcGxpZXMgbm8gcHJvcGVydGllcyovXG5jb25zdCAgICAgICAgaXNPYmplY3Q9KHZhbCk9Pk9iamVjdCh2YWwpPT09dmFsOyRozY9fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRozY9fb25jZS5pc1R5cGVkQXJyYXkoaXNUeXBlZEFycmF5KTtcbmhhcmRlbihpc1R5cGVkQXJyYXkpO1xuXG5jb25zdCAgICAgICAgUEFTU19TVFlMRT1TeW1ib2wuZm9yKCdwYXNzU3R5bGUnKTtcblxuLyoqXG4gKiBGb3IgYSBmdW5jdGlvbiB0byBiZSBhIHZhbGlkIG1ldGhvZCwgaXQgbXVzdCBub3QgYmUgcGFzc2FibGUuXG4gKiBPdGhlcndpc2UsIHdlIHJpc2sgY29uZnVzaW5nIHBhc3MtYnktY29weSBkYXRhIGNhcnJ5aW5nXG4gKiBmYXIgZnVuY3Rpb25zIHdpdGggYXR0ZW1wdHMgYXQgZmFyIG9iamVjdHMgd2l0aCBtZXRob2RzLlxuICpcbiAqIFRPRE8gSEFaQVJEIEJlY2F1c2Ugd2UgY2hlY2sgdGhpcyBvbiB0aGUgd2F5IHRvIGhhcmRlbmluZyBhIHJlbW90YWJsZSxcbiAqIHdlIGNhbm5vdCB5ZXQgY2hlY2sgdGhhdCBgZnVuY2AgaXMgaGFyZGVuZWQuIEhvd2V2ZXIsIHdpdGhvdXRcbiAqIGRvaW5nIHNvLCBpdCdzIGluaGVyaXRhbmNlIG1pZ2h0IGNoYW5nZSBhZnRlciB0aGUgYFBBU1NfU1RZTEVgXG4gKiBjaGVjayBiZWxvdy5cbiAqXG4gKiBAcGFyYW0ge2FueX0gZnVuY1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaM2PX29uY2UuUEFTU19TVFlMRShQQVNTX1NUWUxFKTtcbmNvbnN0ICAgICAgICBjYW5CZU1ldGhvZD0oZnVuYyk9PlxudHlwZW9mIGZ1bmM9PT0nZnVuY3Rpb24nJiYhKFBBU1NfU1RZTEUgaW4gZnVuYyk7JGjNj19vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjNj19vbmNlLmFzc2VydENoZWNrZXIoYXNzZXJ0Q2hlY2tlcik7XG5oYXJkZW4oYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogUmV0dXJucyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIGZ1bmN0aW9uIHRvIGZhaWwgdGhlIHByb3ZpZGVkIENoZWNrZXIgd2l0aCBkZXRhaWxzLlxuICogVGhlIG5hbWUgbXVzdCBiZSBzaG9ydCBmb3IgZXJnb25vbWljIGlubGluZSB1c2UgYXMgaW46XG4gKiBgYGBcbiAqIHJldHVybiBjaGVja0NvbmRpdGlvbiguLi4pIHx8ICghIWNoZWNrICYmIENYKGNoZWNrKWAuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY29uc3QgICAgICAgIENYPShjaGVjayk9PntcbmNvbnN0IHJlamVjdD0oVCwuLi5zdWJzKT0+Y2hlY2soZmFsc2UsWChULC4uLnN1YnMpKTtcbnJldHVybiByZWplY3Q7XG4gfTskaM2PX29uY2UuQ1goQ1gpO1xuaGFyZGVuKENYKTtcblxuLyoqXG4gKiBWZXJpZmllcyB0aGUgcHJlc2VuY2UgYW5kIGVudW1lcmFiaWxpdHkgb2YgYW4gb3duIGRhdGEgcHJvcGVydHlcbiAqIGFuZCByZXR1cm5zIGl0cyBkZXNjcmlwdG9yLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BOYW1lXG4gKiBAcGFyYW0ge2Jvb2xlYW59IHNob3VsZEJlRW51bWVyYWJsZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7UHJvcGVydHlEZXNjcmlwdG9yfVxuICovXG5jb25zdCAgICAgICAgZ2V0T3duRGF0YURlc2NyaXB0b3I9KFxuY2FuZGlkYXRlLFxucHJvcE5hbWUsXG5zaG91bGRCZUVudW1lcmFibGUsXG5jaGVjayk9Plxue1xuY29uc3QgZGVzYz0vKiogQHR5cGUge1Byb3BlcnR5RGVzY3JpcHRvcn0gKi9cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcihjYW5kaWRhdGUscHJvcE5hbWUpO1xuXG5yZXR1cm4oZGVzYyE9PXVuZGVmaW5lZHx8XG4hIWNoZWNrJiZDWChjaGVjaykgYCR7cShwcm9wTmFtZSl9IHByb3BlcnR5IGV4cGVjdGVkOiAke2NhbmRpZGF0ZX1gKSYmKFxuaGFzT3duUHJvcGVydHlPZihkZXNjLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gYWNjZXNzb3IgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWApJiYoXG5zaG91bGRCZUVudW1lcmFibGU/XG5kZXNjLmVudW1lcmFibGV8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGAke3EocHJvcE5hbWUpfSBtdXN0IGJlIGFuIGVudW1lcmFibGUgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWA6XG4hZGVzYy5lbnVtZXJhYmxlfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCk/XG5kZXNjOlxuLyoqIEB0eXBlIHtQcm9wZXJ0eURlc2NyaXB0b3J9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi91bmRlZmluZWQ7XG4gfTskaM2PX29uY2UuZ2V0T3duRGF0YURlc2NyaXB0b3IoZ2V0T3duRGF0YURlc2NyaXB0b3IpO1xuaGFyZGVuKGdldE93bkRhdGFEZXNjcmlwdG9yKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IFRcbiAqIEBwYXJhbSB7SU1QT1JUKCcuL3R5cGVzLmpzJykuUGFzc1N0eWxlZDxhbnksIFQ+fSB0YWdSZWNvcmRcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgZ2V0VGFnPSh0YWdSZWNvcmQpPT50YWdSZWNvcmRbU3ltYm9sLnRvU3RyaW5nVGFnXTskaM2PX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmoscGFzc1N0eWxlLGV4cGVjdGVkUGFzc1N0eWxlLGNoZWNrKT0+e1xucmV0dXJuKFxucGFzc1N0eWxlPT09ZXhwZWN0ZWRQYXNzU3R5bGV8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYEV4cGVjdGVkICR7cShleHBlY3RlZFBhc3NTdHlsZSl9LCBub3QgJHtxKHBhc3NTdHlsZSl9OiAke29ian1gKTtcblxuIH07JGjNj19vbmNlLmNoZWNrUGFzc1N0eWxlKGNoZWNrUGFzc1N0eWxlKTtcbmhhcmRlbihjaGVja1Bhc3NTdHlsZSk7XG5cbmNvbnN0IG1ha2VDaGVja1RhZ1JlY29yZD0oY2hlY2tQcm90byk9Pntcbi8qKlxuICogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVkPGFueSwgYW55Pn0gdGFnUmVjb3JkXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gZXhwZWN0ZWRQYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQsZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNPYmplY3QodGFnUmVjb3JkKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkmJihcbmlzRnJvemVuKHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBIHRhZ1JlY29yZCBtdXN0IGJlIGZyb3plbjogJHt0YWdSZWNvcmR9YCkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBbiBhcnJheSBjYW5ub3QgYmUgYSB0YWdSZWNvcmQ6ICR7dGFnUmVjb3JkfWApJiZcbmNoZWNrUGFzc1N0eWxlKFxudGFnUmVjb3JkLFxuZ2V0T3duRGF0YURlc2NyaXB0b3IodGFnUmVjb3JkLFBBU1NfU1RZTEUsZmFsc2UsY2hlY2spLnZhbHVlLFxuZXhwZWN0ZWRQYXNzU3R5bGUsXG5jaGVjaykmJihcblxudHlwZW9mIGdldE93bkRhdGFEZXNjcmlwdG9yKHRhZ1JlY29yZCxTeW1ib2wudG9TdHJpbmdUYWcsZmFsc2UsY2hlY2spLlxudmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkmJlxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaM2PX29uY2UuY2hlY2tUYWdSZWNvcmQoY2hlY2tUYWdSZWNvcmQpO1xuXG5oYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuXG5jb25zdCAgICAgICAgY2hlY2tGdW5jdGlvblRhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbnByb3RvIT09bnVsbCYmZ2V0UHJvdG90eXBlT2YocHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuISFjaGVjayYmXG5jaGVjayhcbmZhbHNlLFxuWCBgRm9yIGZ1bmN0aW9ucywgYSB0YWdSZWNvcmQgbXVzdCBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlOiAke3ZhbH1gKSk7JGjNj19vbmNlLmNoZWNrRnVuY3Rpb25UYWdSZWNvcmQoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG5cblxuaGFyZGVuKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJDWCI6WyJDWCJdLCJnZXRPd25EYXRhRGVzY3JpcHRvciI6WyJnZXRPd25EYXRhRGVzY3JpcHRvciJdLCJnZXRUYWciOlsiZ2V0VGFnIl0sImNoZWNrUGFzc1N0eWxlIjpbImNoZWNrUGFzc1N0eWxlIl0sImNoZWNrVGFnUmVjb3JkIjpbImNoZWNrVGFnUmVjb3JkIl0sImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiOlsiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZU9mLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vY29weUFycmF5LmpzIiwiLi9jb3B5UmVjb3JkLmpzIiwiLi90YWdnZWQuanMiLCIuL2Vycm9yLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3N5bWJvbC5qcyIsIi4vc2FmZS1wcm9taXNlLmpzIiwiLi9zdHJpbmcuanMiXSwiZXhwb3J0cyI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCIsImFzc2VydFBhc3NhYmxlIiwiaXNQYXNzYWJsZSIsInBhc3NTdHlsZU9mIiwidG9QYXNzYWJsZUVycm9yIiwidG9UaHJvd2FibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgaXNQcm9taXNlLFgsRmFpbCxxLGFubm90YXRlRXJyb3IsbWFrZUVycm9yLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYyxjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcixnZXRFcnJvckNvbnN0cnVjdG9yLGlzRXJyb3JMaWtlLFJlbW90YWJsZUhlbHBlcixhc3NlcnRQYXNzYWJsZVN5bWJvbCxhc3NlcnRTYWZlUHJvbWlzZSxhc3NlcnRQYXNzYWJsZVN0cmluZzskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJhbm5vdGF0ZUVycm9yXCIsIFskaM2PX2EgPT4gKGFubm90YXRlRXJyb3IgPSAkaM2PX2EpXV0sW1wibWFrZUVycm9yXCIsIFskaM2PX2EgPT4gKG1ha2VFcnJvciA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImlzVHlwZWRBcnJheVwiLCBbJGjNj19hID0+IChpc1R5cGVkQXJyYXkgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjNj19hID0+IChDb3B5QXJyYXlIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL2NvcHlSZWNvcmQuanNcIiwgW1tcIkNvcHlSZWNvcmRIZWxwZXJcIiwgWyRozY9fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRozY9fYSldXV1dLFtcIi4vdGFnZ2VkLmpzXCIsIFtbXCJUYWdnZWRIZWxwZXJcIiwgWyRozY9fYSA9PiAoVGFnZ2VkSGVscGVyID0gJGjNj19hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRozY9fYSA9PiAoRXJyb3JIZWxwZXIgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2NcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCIuL3NhZmUtcHJvbWlzZS5qc1wiLCBbW1wiYXNzZXJ0U2FmZVByb21pc2VcIiwgWyRozY9fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaM2PX2EpXV1dXSxbXCIuL3N0cmluZy5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTdHJpbmdcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTdHJpbmcgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGVIZWxwZXJ9IGZyb20gJy4vaW50ZXJuYWwtdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7Q29weUFycmF5LCBDb3B5UmVjb3JkLCBDb3B5VGFnZ2VkLCBQYXNzYWJsZX0gZnJvbSAnLi90eXBlcy5qcycgKi9cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UHJpbWl0aXZlU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbi8qKiBAdHlwZWRlZiB7RXhjbHVkZTxQYXNzU3R5bGUsIFByaW1pdGl2ZVN0eWxlIHwgXCJwcm9taXNlXCI+fSBIZWxwZXJQYXNzU3R5bGUgKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzRnJvemVuLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsdmFsdWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVyc1xuICogQHJldHVybnMge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIFBhc3NTdHlsZUhlbHBlcj4gfVxuICovXG5cbmNvbnN0IG1ha2VIZWxwZXJUYWJsZT0ocGFzc1N0eWxlSGVscGVycyk9Pntcbi8qKiBAdHlwZSB7UmVjb3JkPEhlbHBlclBhc3NTdHlsZSwgYW55PiAmIHtfX3Byb3RvX186IG51bGx9fSAqL1xuY29uc3QgSGVscGVyVGFibGU9e1xuX19wcm90b19fOm51bGwsXG5jb3B5QXJyYXk6dW5kZWZpbmVkLFxuY29weVJlY29yZDp1bmRlZmluZWQsXG50YWdnZWQ6dW5kZWZpbmVkLFxuZXJyb3I6dW5kZWZpbmVkLFxucmVtb3RhYmxlOnVuZGVmaW5lZH07XG5cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5jb25zdHtzdHlsZU5hbWV9PWhlbHBlcjtcbnN0eWxlTmFtZSBpbiBIZWxwZXJUYWJsZXx8RmFpbCBgVW5yZWNvZ25pemVkIGhlbHBlcjogJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09PT11bmRlZmluZWR8fFxuRmFpbCBgY29uZmxpY3RpbmcgaGVscGVycyBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09aGVscGVyO1xuIH1cbmZvcihjb25zdCBzdHlsZU5hbWUgb2Ygb3duS2V5cyhIZWxwZXJUYWJsZSkpe1xuSGVscGVyVGFibGVbc3R5bGVOYW1lXSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBtaXNzaW5nIGhlbHBlciBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbiB9XG5cbnJldHVybiBoYXJkZW4oSGVscGVyVGFibGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVycyBUaGUgcGFzc1N0eWxlSGVscGVycyB0byByZWdpc3RlcixcbiAqIGluIHByaW9yaXR5IG9yZGVyLlxuICogTk9URSBUaGVzZSBtdXN0IGFsbCBiZSBcInRydXN0ZWRcIixcbiAqIGNvbXBsZXRlLCBhbmQgbm9uLWNvbGxpZGluZy4gYG1ha2VQYXNzU3R5bGVPZmAgbWF5ICphc3N1bWUqIHRoYXQgZWFjaCBoZWxwZXJcbiAqIGRvZXMgd2hhdCBpdCBpcyBzdXBwb3NlZCB0byBkby4gYG1ha2VQYXNzU3R5bGVPZmAgaXMgbm90IHRyeWluZyB0byBkZWZlbmRcbiAqIGl0c2VsZiBhZ2FpbnN0IG1hbGljaW91cyBoZWxwZXJzLCB0aG91Z2ggaXQgZG9lcyBkZWZlbmQgYWdhaW5zdCBzb21lXG4gKiBhY2NpZGVudHMuXG4gKiBAcmV0dXJucyB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IG1ha2VQYXNzU3R5bGVPZj0ocGFzc1N0eWxlSGVscGVycyk9PntcbmNvbnN0IEhlbHBlclRhYmxlPW1ha2VIZWxwZXJUYWJsZShwYXNzU3R5bGVIZWxwZXJzKTtcbmNvbnN0IHJlbW90YWJsZUhlbHBlcj1IZWxwZXJUYWJsZS5yZW1vdGFibGU7XG5cbi8qKlxuICogUHVyZWx5IGZvciBwZXJmb3JtYW5jZS4gSG93ZXZlciBpdCBpcyBtdXRhYmxlIHN0YXRpYyBzdGF0ZSwgYW5kXG4gKiBpdCBkb2VzIGhhdmUgc29tZSBvYnNlcnZhYmlsaXR5IG9uIHByb3hpZXMuIFRPRE8gbmVlZCB0byBhc3Nlc3NcbiAqIHdoZXRoZXIgdGhpcyBjcmVhdGVzIGEgc3RhdGljIGNvbW11bmljYXRpb25zIGNoYW5uZWwuXG4gKlxuICogcGFzc1N0eWxlT2YgZG9lcyBhIGZ1bGwgcmVjdXJzaXZlIHdhbGsgb2YgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBpbiBvcmRlciB0byB2YWxpZGF0ZSB0aGF0IHRoZXkgYXJlIGFjeWNsaWMuIEluIGFkZGl0aW9uXG4gKiBpdCBpcyB1c2VkIGJ5IG90aGVyIGFsZ29yaXRobXMgdG8gcmVjdXJzaXZlbHkgd2FsayB0aGVzZSBwYXNzLWJ5LWNvcHlcbiAqIHN0cnVjdHVyZXMsIHNvIHdpdGhvdXQgdGhpcyBjYWNoZSwgdGhlc2UgYWxnb3JpdGhtcyBjb3VsZCBiZVxuICogTyhOKioyKSBvciB3b3JzZS5cbiAqXG4gKiBAdHlwZSB7V2Vha01hcDxXZWFrS2V5LCBQYXNzU3R5bGU+fVxuICovXG5jb25zdCBwYXNzU3R5bGVNZW1vPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZU9mfVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgcGFzc1N0eWxlT2Y9KHBhc3NhYmxlKT0+e1xuLyogRXZlbiB3aGVuIGEgV2Vha1NldCBpcyBjb3JyZWN0LCB3aGVuIHRoZSBzZXQgaGFzIGEgc2hvcnRlciBsaWZldGltZSovXG4vKiB0aGFuIGl0cyBrZXlzLCB3ZSBwcmVmZXIgYSBTZXQgZHVlIHRvIGV4cGVjdGVkIGltcGxlbWVudGF0aW9uKi9cbi8qIHRyYWRlb2Zmcy4qL1xuY29uc3QgaW5Qcm9ncmVzcz1uZXcgU2V0KCk7XG5cbmNvbnN0IHBhc3NTdHlsZU9mUmVjdXI9KGlubmVyKT0+e1xuY29uc3QgaW5uZXJJc09iamVjdD1pc09iamVjdChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbmNvbnN0IGlubmVyU3R5bGU9cGFzc1N0eWxlTWVtby5nZXQoaW5uZXIpO1xuaWYoaW5uZXJTdHlsZSl7XG5yZXR1cm4gaW5uZXJTdHlsZTtcbiB9XG4haW5Qcm9ncmVzcy5oYXMoaW5uZXIpfHxcbkZhaWwgYFBhc3MtYnktY29weSBkYXRhIGNhbm5vdCBiZSBjeWNsaWMgJHtpbm5lcn1gO1xuaW5Qcm9ncmVzcy5hZGQoaW5uZXIpO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2ZJbnRlcm5hbChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbnBhc3NTdHlsZU1lbW8uc2V0KGlubmVyLHBhc3NTdHlsZSk7XG5pblByb2dyZXNzLmRlbGV0ZShpbm5lcik7XG4gfVxucmV0dXJuIHBhc3NTdHlsZTtcbiB9O1xuXG5jb25zdCBwYXNzU3R5bGVPZkludGVybmFsPShpbm5lcik9PntcbmNvbnN0IHR5cGVzdHI9dHlwZW9mIGlubmVyO1xuc3dpdGNoKHR5cGVzdHIpe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzpcbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gdHlwZXN0cjtcbiB9XG5jYXNlJ3N0cmluZyc6e1xuYXNzZXJ0UGFzc2FibGVTdHJpbmcoaW5uZXIpO1xucmV0dXJuJ3N0cmluZyc7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKGlubmVyKTtcbnJldHVybidzeW1ib2wnO1xuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihpbm5lcj09PW51bGwpe1xucmV0dXJuJ251bGwnO1xuIH1cbmlmKCFpc0Zyb3plbihpbm5lcikpe1xuYXNzZXJ0LmZhaWwoXG4vKiBUeXBlZEFycmF5cyBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgaW4gaGFyZGVuKCkqL1xuLyogYW5kIGEgY29ycmVzcG9uZGluZyBzcGVjaWFsIGVycm9yIG1lc3NhZ2UgaGVyZS4qL1xuaXNUeXBlZEFycmF5KGlubmVyKT9cblggYENhbm5vdCBwYXNzIG11dGFibGUgdHlwZWQgYXJyYXlzIGxpa2UgJHtpbm5lcn0uYDpcblggYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgKTtcblxuIH1cbmlmKGlzUHJvbWlzZShpbm5lcikpe1xuYXNzZXJ0U2FmZVByb21pc2UoaW5uZXIpO1xucmV0dXJuJ3Byb21pc2UnO1xuIH1cbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xuY29uc3QgcGFzc1N0eWxlVGFnPWlubmVyW1BBU1NfU1RZTEVdO1xuaWYocGFzc1N0eWxlVGFnIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YocGFzc1N0eWxlVGFnLCdzdHJpbmcnKTtcbmNvbnN0IGhlbHBlcj1IZWxwZXJUYWJsZVtwYXNzU3R5bGVUYWddO1xuaGVscGVyIT09dW5kZWZpbmVkfHxcbkZhaWwgYFVucmVjb2duaXplZCBQYXNzU3R5bGU6ICR7cShwYXNzU3R5bGVUYWcpfWA7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc1N0eWxlfSAqL3Bhc3NTdHlsZVRhZyk7XG4gfVxuZm9yKGNvbnN0IGhlbHBlciBvZiBwYXNzU3R5bGVIZWxwZXJzKXtcbmlmKGhlbHBlci5jYW5CZVZhbGlkKGlubmVyKSl7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gaGVscGVyLnN0eWxlTmFtZTtcbiB9XG4gfVxucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuY2FzZSdmdW5jdGlvbic6e1xuaXNGcm96ZW4oaW5uZXIpfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgO1xudHlwZW9mIGlubmVyLnRoZW4hPT0nZnVuY3Rpb24nfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1wcm9taXNlIHRoZW5hYmxlc2A7XG5yZW1vdGFibGVIZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4ncmVtb3RhYmxlJztcbiB9XG5kZWZhdWx0OntcbnRocm93IGFzc2VydC5mYWlsKFggYFVucmVjb2duaXplZCB0eXBlb2YgJHtxKHR5cGVzdHIpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTtcblxucmV0dXJuIHBhc3NTdHlsZU9mUmVjdXIocGFzc2FibGUpO1xuIH07XG5yZXR1cm4gaGFyZGVuKHBhc3NTdHlsZU9mKTtcbiB9O1xuXG5jb25zdCAgICAgICAgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2w9U3ltYm9sLmZvcignQGVuZG8gcGFzc1N0eWxlT2YnKTtcblxuLyoqXG4gKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2wgcHJvcGVydHkgb24gdGhlIGdsb2JhbCxcbiAqIHRoZW4gcHJlc3VtYWJseSBpdCB3YXMgZW5kb3dlZCBmb3IgdXMgYnkgbGl2ZXNsb3RzIHdpdGggYSBgcGFzc1N0eWxlT2ZgXG4gKiBmdW5jdGlvbiwgc28gd2Ugc2hvdWxkIHVzZSBhbmQgZXhwb3J0IHRoYXQgb25lIGluc3RlYWQuXG4gKiBPdGhlciBzb2Z0d2FyZSBtYXkgaGF2ZSBsZWZ0IGl0IGZvciB1cyBoZXJlLFxuICogYnV0IGl0IHdvdWxkIHJlcXVpcmUgd3JpdGUgYWNjZXNzIHRvIG91ciBnbG9iYWwsIG9yIHRoZSBhYmlsaXR5IHRvXG4gKiBwcm92aWRlIGVuZG93bWVudHMgdG8gb3VyIGdsb2JhbCwgYm90aCBvZiB3aGljaCBzZWVtcyBhZGVxdWF0ZSBhcyBhIHRlc3Qgb2ZcbiAqIHdoZXRoZXIgaXQgaXMgYXV0aG9yaXplZCB0byBzZXJ2ZSB0aGUgc2FtZSByb2xlIGFzIGxpdmVzbG90cy5cbiAqXG4gKiBOT1RFIEhBWkFSRDogVGhpcyB1c2UgYnkgbGl2ZXNsb3RzIGRvZXMgcmVseSBvbiBgcGFzc1N0eWxlT2ZgIGJlaW5nXG4gKiBkZXRlcm1pbmlzdGljLiBJZiBpdCBpcyBub3QsIHRoZW4gaW4gYSBsaXZlc2xvdC1saWtlIHZpcnR1YWxpemVkXG4gKiBlbnZpcm9ubWVudCwgaXQgY2FuIGJlIHVzZWQgdG8gZGV0ZWN0IEdDLlxuICpcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqLyRozY9fb25jZS5QYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbChQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCk7XG5jb25zdCAgICAgICAgcGFzc1N0eWxlT2Y9XG5nbG9iYWxUaGlzJiZnbG9iYWxUaGlzW1Bhc3NTdHlsZU9mRW5kb3dtZW50U3ltYm9sXXx8XG5tYWtlUGFzc1N0eWxlT2YoW1xuQ29weUFycmF5SGVscGVyLFxuQ29weVJlY29yZEhlbHBlcixcblRhZ2dlZEhlbHBlcixcbkVycm9ySGVscGVyLFxuUmVtb3RhYmxlSGVscGVyXSk7JGjNj19vbmNlLnBhc3NTdHlsZU9mKHBhc3NTdHlsZU9mKTtcblxuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGU9KHZhbCk9PntcbnBhc3NTdHlsZU9mKHZhbCk7LyogdGhyb3dzIGlmIHZhbCBpcyBub3QgYSBwYXNzYWJsZSovXG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcblxuLyoqXG4gKiBJcyBgc3BlY2ltZW5gIFBhc3NhYmxlPyBUaGlzIHJldHVybnMgdHJ1ZSBpZmYgYHBhc3NTdHlsZU9mKHNwZWNpbWVuKWBcbiAqIHJldHVybnMgYSBzdHJpbmcuIFRoaXMgcmV0dXJucyBgZmFsc2VgIGlmZiBgcGFzc1N0eWxlT2Yoc3BlY2ltZW4pYCB0aHJvd3MuXG4gKiBVbmRlciBubyBub3JtYWwgY2lyY3Vtc3RhbmNlIHNob3VsZCBgaXNQYXNzYWJsZShzcGVjaW1lbilgIHRocm93LlxuICpcbiAqIFRPRE8gRGVwcmVjYXRlIGFuZCB1bHRpbWF0ZWx5IGRlbGV0ZSBAYWdvcmljL2Jhc2Utem9uZSdzIGBpc1Bhc3NhYmxlJyBpblxuICogZmF2b3Igb2YgdGhpcyBvbmUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8yMDk2XG4gKlxuICogVE9ETyBpbXBsZW1lbnQgYW4gaXNQYXNzYWJsZSB0aGF0IGRvZXMgbm90IHJlbHkgb24gdHJ5L2NhdGNoLlxuICogVGhpcyBpbXBsZW1lbnRhdGlvbiBpcyBqdXN0IGEgc3RhbmRpbiB1bnRpbCB0aGVuLlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMjA5NlxuICpcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHJldHVybnMge3NwZWNpbWVuIGlzIFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgaXNQYXNzYWJsZT0oc3BlY2ltZW4pPT57XG50cnl7XG4vKiBJbiBmYWN0LCBpdCBuZXZlciByZXR1cm5zIHVuZGVmaW5lZC4gSXQgZWl0aGVyIHJldHVybnMgYSovXG4vKiBzdHJpbmcgb3IgdGhyb3dzLiovXG5yZXR1cm4gcGFzc1N0eWxlT2Yoc3BlY2ltZW4pIT09dW5kZWZpbmVkO1xuIH1jYXRjaChfKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfTskaM2PX29uY2UuaXNQYXNzYWJsZShpc1Bhc3NhYmxlKTtcbmhhcmRlbihpc1Bhc3NhYmxlKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc1Bhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2M9KG5hbWUsZGVzYyk9PlxuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MobmFtZSxkZXNjLHBhc3NTdHlsZU9mKTtcblxuLyoqXG4gKiBBZnRlciBoYXJkZW5pbmcsIGlmIGBlcnJgIGlzIGEgcGFzc2FibGUgZXJyb3IsIHJldHVybiBpdC5cbiAqXG4gKiBPdGhlcndpc2UsIHJldHVybiBhIG5ldyBwYXNzYWJsZSBlcnJvciB0aGF0IHByb3BhZ2F0ZXMgdGhlIGRpYWdub3N0aWNcbiAqIGluZm8gb2YgdGhlIG9yaWdpbmFsLCBhbmQgaXMgbGlua2VkIHRvIHRoZSBvcmlnaW5hbCBhcyBhIG5vdGUuXG4gKlxuICogVE9ETyBBZG9wdCBhIG1vcmUgZmxleGlibGUgbm90aW9uIG9mIHBhc3NhYmxlIGVycm9yLCBpbiB3aGljaFxuICogYSBwYXNzYWJsZSBlcnJvciBjYW4gY29udGFpbiBvdGhlciBvd24gZGF0YSBwcm9wZXJ0aWVzIHdpdGhcbiAqIHRocm93YWJsZSB2YWx1ZXMuXG4gKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0ICAgICAgICB0b1Bhc3NhYmxlRXJyb3I9KGVycik9PntcbmhhcmRlbihlcnIpO1xuaWYoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mKSl7XG5yZXR1cm4gZXJyO1xuIH1cbmNvbnN0e25hbWUsbWVzc2FnZX09ZXJyO1xuY29uc3R7Y2F1c2U6Y2F1c2VEZXNjLGVycm9yczplcnJvcnNEZXNjfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoZXJyKTtcbmxldCBjYXVzZTtcbmxldCBlcnJvcnM7XG5pZihjYXVzZURlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnY2F1c2UnLGNhdXNlRGVzYykpe1xuY2F1c2U9Y2F1c2VEZXNjLnZhbHVlO1xuIH1cbmlmKGVycm9yc0Rlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnZXJyb3JzJyxlcnJvcnNEZXNjKSl7XG5lcnJvcnM9ZXJyb3JzRGVzYy52YWx1ZTtcbiB9XG5cbmNvbnN0IGVyckNvbnN0cnVjdG9yPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9bWFrZUVycm9yKCBgJHttZXNzYWdlfWAsZXJyQ29uc3RydWN0b3Ise1xuLyogQHRzLWlnbm9yZSBBc3N1bWluZyBjYXVzZSBpcyBFcnJvciB8IHVuZGVmaW5lZCovXG5jYXVzZSxcbmVycm9yc30pO1xuXG4vKiBTdGlsbCBuZWVkZWQsIGJlY2F1c2UgYG1ha2VFcnJvcmAgb25seSBkb2VzIGEgc2hhbGxvdyBmcmVlemUuKi9cbmhhcmRlbihuZXdFcnJvcik7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hbm5vdGF0ZUVycm9yKG5ld0Vycm9yLFggYGNvcGllZCBmcm9tIGVycm9yICR7ZXJyfWApO1xucGFzc1N0eWxlT2YobmV3RXJyb3IpPT09J2Vycm9yJ3x8XG5GYWlsIGBFeHBlY3RlZCAke25ld0Vycm9yfSB0byBiZSBhIHBhc3NhYmxlIGVycm9yYDtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRozY9fb25jZS50b1Bhc3NhYmxlRXJyb3IodG9QYXNzYWJsZUVycm9yKTtcbmhhcmRlbih0b1Bhc3NhYmxlRXJyb3IpO1xuXG4vKipcbiAqIEFmdGVyIGhhcmRlbmluZywgaWYgYHNwZWNpbWVuYCBpcyB0aHJvd2FibGUsIHJldHVybiBpdC5cbiAqIEEgc3BlY2ltZW4gaXMgdGhyb3dhYmxlIGlmZiBpdCBpcyBQYXNzYWJsZSBhbmQgY29udGFpbnMgbm8gUGFzc2FibGVDYXBzLFxuICogaS5lLiwgbm8gUmVtb3RhYmxlcyBvciBQcm9taXNlcy5cbiAqIElPVywgaWYgaXQgY29udGFpbnMgb25seSBjb3B5LWRhdGEgYW5kIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBPdGhlcndpc2UsIGlmIGBzcGVjaW1lbmAgaXMgKmFsbW9zdCogdGhyb3dhYmxlLCBmb3IgZXhhbXBsZSwgaXQgaXNcbiAqIGFuIGVycm9yIHRoYXQgY2FuIGJlIG1hZGUgdGhyb3dhYmxlIGJ5IGB0b1Bhc3NhYmxlRXJyb3JgLCB0aGVuXG4gKiByZXR1cm4gYHNwZWNpbWVuYCBjb252ZXJ0ZWQgdG8gYSB0aHJvd2FibGUuXG4gKlxuICogT3RoZXJ3aXNlLCB0aHJvdyBhIGRpYWdub3N0aWMgaW5kaWNhdGluZyBhIGZhaWx1cmUgdG8gY29lcmNlLlxuICpcbiAqIFRoaXMgaXMgaW4gc3VwcG9ydCBvZiB0aGUgZXhvIGJvdW5kYXJ5IHRocm93aW5nIG9ubHkgdGhyb3dhYmxlcywgdG8gZWFzZVxuICogc2VjdXJpdHkgcmV2aWV3LlxuICpcbiAqIFRPRE8gQWRvcHQgYSBtb3JlIGZsZXhpdGJsZSBub3Rpb24gb2YgdGhyb3dhYmxlLCBpbiB3aGljaFxuICogZGF0YSBjb250YWluZXJzIGNvbnRhaW5pbmcgbm9uLXBhc3NhYmxlIGVycm9ycyBjYW4gdGhlbXNlbHZlcyBiZSBjb2VyY2VkXG4gKiB0byB0aHJvd2FibGUgYnkgY29lcmNpbmcgdG8gYSBzaW1pbGFyIGNvbnRhaW5lcnMgY29udGFpbmluZ1xuICogdGhlIHJlc3VsdHMgb2YgY29lcmNpbmcgdGhvc2UgZXJyb3JzIHRvIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHNwZWNpbWVuXG4gKiBAcmV0dXJucyB7UGFzc2FibGU8bmV2ZXIsIEVycm9yPn1cbiAqL1xuY29uc3QgICAgICAgIHRvVGhyb3dhYmxlPShzcGVjaW1lbik9PntcbmhhcmRlbihzcGVjaW1lbik7XG5pZihpc0Vycm9yTGlrZShzcGVjaW1lbikpe1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcigvKiogQHR5cGUge0Vycm9yfSAqL3NwZWNpbWVuKTtcbiB9XG4vKiBOb3RlIHRoYXQgdGhpcyBzdGVwIHdpbGwgZmFpbCBpZiBgc3BlY2ltZW5gIHdvdWxkIGJlIGEgcGFzc2FibGUgY29udGFpbmVyKi9cbi8qIGV4Y2VwdCB0aGF0IGl0IGNvbnRhaW5zIG5vbi1wYXNzYWJsZSBlcnJvcnMgdGhhdCBjb3VsZCBiZSBjb252ZXJ0ZWQuKi9cbi8qIFRoaXMgd2lsbCBuZWVkIHRvIGJlIGZpeGVkIHRvIGRvIHRoZSBUT0RPIGFib3ZlLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2Yoc3BlY2ltZW4pO1xuaWYoaXNPYmplY3Qoc3BlY2ltZW4pKXtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5QXJyYXknOntcbmNvbnN0IGVsZW1lbnRzPS8qKiBAdHlwZSB7Q29weUFycmF5fSAqL3NwZWNpbWVuO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgZWxlbWVudHMpe1xuZWxlbWVudD09PXRvVGhyb3dhYmxlKGVsZW1lbnQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke2VsZW1lbnR9YDtcbiB9XG5icmVhaztcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmNvbnN0IHJlYz0vKiogQHR5cGUge0NvcHlSZWNvcmR9ICovc3BlY2ltZW47XG5mb3IoY29uc3QgdmFsIG9mIHZhbHVlcyhyZWMpKXtcbnZhbD09PXRvVGhyb3dhYmxlKHZhbCl8fFxuRmFpbCBgbmVzdGVkIHRvVGhyb3dhYmxlIGNvZXJjaW9uIG5vdCB5ZXQgc3VwcG9ydGVkICR7dmFsfWA7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRnPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi9zcGVjaW1lbjtcbmNvbnN0e3BheWxvYWR9PXRnO1xucGF5bG9hZD09PXRvVGhyb3dhYmxlKHBheWxvYWQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke3BheWxvYWR9YDtcbmJyZWFrO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVyPS8qKiBAdHlwZSB7RXJyb3J9ICovc3BlY2ltZW47XG5lcj09PXRvVGhyb3dhYmxlKGVyKXx8XG5GYWlsIGBuZXN0ZWQgdG9UaHJvd2FibGUgY29lcmNpb24gbm90IHlldCBzdXBwb3J0ZWQgJHtlcn1gO1xuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBBICR7cShwYXNzU3R5bGUpfSBpcyBub3QgdGhyb3dhYmxlOiAke3NwZWNpbWVufWA7XG4gfX1cblxuIH1cbnJldHVybiAoLyoqIEB0eXBlIHtQYXNzYWJsZTxuZXZlcixuZXZlcj59ICovc3BlY2ltZW4pO1xuIH07JGjNj19vbmNlLnRvVGhyb3dhYmxlKHRvVGhyb3dhYmxlKTtcbmhhcmRlbih0b1Rocm93YWJsZSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCJdLCJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdLCJpc1Bhc3NhYmxlIjpbImlzUGFzc2FibGUiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdLCJ0b1Rocm93YWJsZSI6WyJ0b1Rocm93YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACC5ALHEiIAABIiAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEsYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxoYXNPd25Qcm9wZXJ0eU9mLFBBU1NfU1RZTEUsY2hlY2tUYWdSZWNvcmQsY2hlY2tGdW5jdGlvblRhZ1JlY29yZCxpc09iamVjdCxnZXRUYWcsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjNj19hID0+IChjaGVja1RhZ1JlY29yZCA9ICRozY9fYSldXSxbXCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQgPSAkaM2PX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRozY9fYSA9PiAoaXNPYmplY3QgPSAkaM2PX2EpXV0sW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDaGVja2VyfSBmcm9tICcuL3R5cGVzLmpzJ1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlYywgUGFzc1N0eWxlZH0gZnJvbSAnLi90eXBlcy5qcydcbiAqIEBpbXBvcnQge1Bhc3NTdHlsZUhlbHBlcn0gZnJvbSAnLi9pbnRlcm5hbC10eXBlcy5qcydcbiAqIEBpbXBvcnQge1JlbW90YWJsZU9iamVjdCBhcyBSZW1vdGFibGV9IGZyb20gJy4vdHlwZXMuanMnXG4gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZSxcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICovXG5jb25zdCBjaGVja0lmYWNlPShpZmFjZSxjaGVjayk9PntcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRm9yIG5vdywgaW50ZXJmYWNlICR7aWZhY2V9IG11c3QgYmUgYSBzdHJpbmc7IHVuaW1wbGVtZW50ZWRgKSYmKFxuaWZhY2U9PT0nUmVtb3RhYmxlJ3x8XG5pZmFjZS5zdGFydHNXaXRoKCdBbGxlZ2VkOiAnKXx8XG5pZmFjZS5zdGFydHNXaXRoKCdEZWJ1Z05hbWU6ICcpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGb3Igbm93LCBpZmFjZSAke3EoXG5pZmFjZSlcbiB9IG11c3QgYmUgXCJSZW1vdGFibGVcIiBvciBiZWdpbiB3aXRoIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiOyB1bmltcGxlbWVudGVkYCkpO1xuXG4gfTtcblxuLyoqXG4gKiBBbiBgaWZhY2VgIG11c3QgYmUgcHVyZS4gUmlnaHQgbm93IGl0IG11c3QgYmUgYSBzdHJpbmcsIHdoaWNoIGlzIHB1cmUuXG4gKiBMYXRlciB3ZSBleHBlY3QgdG8gaW5jbHVkZSBzb21lIG90aGVyIHZhbHVlcyB0aGF0IHF1YWxpZnkgYXMgYFB1cmVEYXRhYCxcbiAqIHdoaWNoIGlzIGEgcGFzcy1ieS1jb3B5IHN1cGVyc3RydWN0dXJlIGVuZGluZyBvbmx5IGluIHByaW1pdGl2ZXMgb3JcbiAqIGVtcHR5IHBhc3MtYnktY29weSBjb21wb3NpdGVzLiBObyByZW1vdGFibGVzLCBwcm9taXNlcywgb3IgZXJyb3JzLlxuICogV2UgKmFzc3VtZSogZm9yIG5vdyB0aGF0IHRoZSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgY29udGFpbnMgbm9cbiAqIHByb3hpZXMuXG4gKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0SWZhY2U9KGlmYWNlKT0+Y2hlY2tJZmFjZShpZmFjZSxhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmlzT2JqZWN0KG9yaWdpbmFsKXx8XG5GYWlsIGBSZW1vdGFibGVzIG11c3QgYmUgb2JqZWN0cyBvciBmdW5jdGlvbnM6ICR7b3JpZ2luYWx9YDtcblxuLyogQSB2YWxpZCByZW1vdGFibGUgb2JqZWN0IG11c3QgaW5oZXJpdCBmcm9tIGEgXCJ0YWcgcmVjb3JkXCIgLS0gYSovXG4vKiBwbGFpbi1vYmplY3QgcHJvdG90eXBlIGNvbnNpc3Rpbmcgb2Ygb25seSovXG4vKiBhIGBQQVNTX1NUWUxFYCBwcm9wZXJ0eSB3aXRoIHZhbHVlIFwicmVtb3RhYmxlXCIgYW5kIGEgc3VpdGFibGUgYFN5bWJvbC50b1N0cmluZ1RhZ2AqL1xuLyogcHJvcGVydHkuIFRoZSByZW1vdGFibGUgY291bGQgaW5oZXJpdCBkaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLCBvciovXG4vKiBpdCBjb3VsZCBpbmhlcml0IGZyb20gYW5vdGhlciB2YWxpZCByZW1vdGFibGUsIHRoYXQgdGhlcmVmb3JlIGl0c2VsZiovXG4vKiBpbmhlcml0cyBkaXJlY3RseSBvciBpbmRpcmVjdGx5IGZyb20gc3VjaCBhIHRhZyByZWNvcmQuKi9cbi8qKi9cbi8qIFRPRE86IEl0IHdvdWxkIGJlIG5pY2UgdG8gdHlwZWRlZiB0aGlzIHNoYXBlLCBidXQgd2UgY2FuJ3QgZGVjbGFyZSBhIHR5cGUqL1xuLyogd2l0aCBQQVNTX1NUWUxFIGZyb20gSlNEb2MuKi9cbi8qKi9cbi8qIEB0eXBlIHt7IFtQQVNTX1NUWUxFXTogc3RyaW5nLCovXG4vKiBbU3ltYm9sLnRvU3RyaW5nVGFnXTogc3RyaW5nLCovXG4vKiB9fSovXG4vKiovXG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihvcmlnaW5hbCk7XG5pZihcbnByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbnByb3RvPT09bnVsbHx8XG5wcm90bz09PUZ1bmN0aW9uLnByb3RvdHlwZSlcbntcbnJldHVybihcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZW1vdGFibGVzIG11c3QgYmUgZXhwbGljaXRseSBkZWNsYXJlZDogJHtxKG9yaWdpbmFsKX1gKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gUmVtb3RhYmxlIFByb3RvICR7b3duS2V5cyhyZXN0RGVzY3MpfWApJiZcbmNoZWNrSWZhY2UoaWZhY2UsY2hlY2spKTtcblxuIH07XG5cbi8qKlxuICogS2VlcCBhIHdlYWsgc2V0IG9mIGNvbmZpcm1lZCByZW1vdGFibGVzIGZvciBtYXJzaGFsIHBlcmZvcm1hbmNlXG4gKiAod2l0aG91dCB3aGljaCB3ZSB3b3VsZCBpbmN1ciBhIHJlZHVuZGFudCB2ZXJpZmljYXRpb24gaW5cbiAqIGdldEludGVyZmFjZU9mKS5cbiAqIFdlIGRvbid0IHJlbWVtYmVyIHJlamVjdGlvbnMgYmVjYXVzZSB0aGV5IGFyZSBwb3NzaWJsZSB0byBjb3JyZWN0XG4gKiB3aXRoIGUuZy4gYGhhcmRlbmAuXG4gKlxuICogQHR5cGUge1dlYWtTZXQ8UmVtb3RhYmxlPn1cbiAqL1xuY29uc3QgY29uZmlybWVkUmVtb3RhYmxlcz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge3ZhbCBpcyBSZW1vdGFibGV9XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlPSh2YWwsY2hlY2spPT57XG5pZihjb25maXJtZWRSZW1vdGFibGVzLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybihcbiEhY2hlY2smJkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke3ZhbH1gKTtcblxuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIFNpbXBsZSBzZW1hbnRpY3MsIGp1c3QgdGVsbCB3aGF0IGludGVyZmFjZSBzcGVjIGEgUmVtb3RhYmxlIGhhcyxcbiAqIG9yIHVuZGVmaW5lZCBpZiBub3QgZGVlbWVkIHRvIGJlIGEgUmVtb3RhYmxlLlxuICpcbiAqIEB0eXBlIHt7XG4gKiA8VCBleHRlbmRzIHN0cmluZz4odmFsOiBQYXNzU3R5bGVkPGFueSwgVD4pOiBUO1xuICogKHZhbDogYW55KTogSW50ZXJmYWNlU3BlYyB8IHVuZGVmaW5lZDtcbiAqIH19XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbi8qIEB0cy1leHBlY3QtZXJyb3IgbmFycm93ZWQqL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5hcnJvd2VkKi9cbnJldHVybiBnZXRUYWcodmFsKTtcbiB9OyRozY9fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCB2YWxpZFR5cGU9XG4oaXNPYmplY3QoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tb2JqZWN0cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgYXJyYXlzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKTtcbmlmKCF2YWxpZFR5cGUpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xuaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdvYmplY3QnKXtcbi8qIEV2ZXJ5IG93biBwcm9wZXJ0eSAocmVnYXJkbGVzcyBvZiBlbnVtZXJhYmlsaXR5KSovXG4vKiBtdXN0IGhhdmUgYSBmdW5jdGlvbiB2YWx1ZS4qL1xucmV0dXJuIG93bktleXMoZGVzY3MpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4vKiBUeXBlY2FzdCBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG4oaGFzT3duUHJvcGVydHlPZihkZXNjc1svKiogQHR5cGUge3N0cmluZ30gKi9rZXldLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBjYW5ub3Qgc2VyaWFsaXplIFJlbW90YWJsZXMgd2l0aCBhY2Nlc3NvcnMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApJiYoXG5rZXk9PT1TeW1ib2wudG9TdHJpbmdUYWcmJmNoZWNrSWZhY2UoY2FuZGlkYXRlW2tleV0sY2hlY2spfHxcbihjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIG5vbi1tZXRob2RzIGxpa2UgJHtxKFxuU3RyaW5nKGtleSkpXG4gfSBpbiAke2NhbmRpZGF0ZX1gKSYmKFxua2V5IT09UEFTU19TVFlMRXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpO1xuXG4gfSk7XG4gfWVsc2UgaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdmdW5jdGlvbicpe1xuLyogRmFyIGZ1bmN0aW9ucyBjYW5ub3QgYmUgbWV0aG9kcywgYW5kIGNhbm5vdCBoYXZlIG1ldGhvZHMuKi9cbi8qIFRoZXkgbXVzdCBoYXZlIGV4YWN0bHkgZXhwZWN0ZWQgYC5uYW1lYCBhbmQgYC5sZW5ndGhgIHByb3BlcnRpZXMqL1xuY29uc3R7XG5uYW1lOm5hbWVEZXNjLFxubGVuZ3RoOmxlbmd0aERlc2MsXG4vKiBAdHMtaWdub3JlIFRTIGRvZXNuJ3QgbGlrZSBzeW1ib2xzIGFzIGNvbXB1dGVkIGluZGV4ZXM/PyovXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp0b1N0cmluZ1RhZ0Rlc2MsXG4uLi5yZXN0RGVzY3N9PVxuZGVzY3M7XG5jb25zdCByZXN0S2V5cz1vd25LZXlzKHJlc3REZXNjcyk7XG5yZXR1cm4oXG4obmFtZURlc2MmJnR5cGVvZiBuYW1lRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGYXIgZnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbiBsZW5ndGggbXVzdCBiZSBhIG51bWJlciwgaW4gJHtjYW5kaWRhdGV9YCkmJihcbnRvU3RyaW5nVGFnRGVzYz09PXVuZGVmaW5lZHx8XG4odHlwZW9mIHRvU3RyaW5nVGFnRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRmFyIGZ1bmN0aW9uIEBAdG9TdHJpbmdUYWcgbXVzdCBiZSBhIHN0cmluZywgaW4gJHtjYW5kaWRhdGV9YCkmJlxuY2hlY2tJZmFjZSh0b1N0cmluZ1RhZ0Rlc2MudmFsdWUsY2hlY2spKSYmKFxucmVzdEtleXMubGVuZ3RoPT09MHx8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSk7XG5cbiB9XG5yZXR1cm4hIWNoZWNrJiZDWChjaGVjaykgYHVucmVjb2duaXplZCB0eXBlb2YgJHtjYW5kaWRhdGV9YDtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaM2PX29uY2UuUmVtb3RhYmxlSGVscGVyKFJlbW90YWJsZUhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJZmFjZSI6WyJhc3NlcnRJZmFjZSJdLCJnZXRJbnRlcmZhY2VPZiI6WyJnZXRJbnRlcmZhY2VPZiJdLCJSZW1vdGFibGVIZWxwZXIiOlsiUmVtb3RhYmxlSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAARGFca6FAAAuhQAACsAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbImFzc2VydFNhZmVQcm9taXNlIiwiaXNTYWZlUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBpc1Byb21pc2UscSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2YsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wiaXNQcm9taXNlXCIsIFskaM2PX2EgPT4gKGlzUHJvbWlzZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge0NoZWNrZXJ9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2lzRnJvemVuLGdldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e3RvU3RyaW5nVGFnfT1TeW1ib2w7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCBrZXlzPW93bktleXMocHIpO1xuXG5pZihrZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG4vKipcbiAqIFRoaXMgZXhjbHVkZXMgdGhvc2Ugc3ltYm9sLW5hbWVkIG93biBwcm9wZXJ0aWVzIHRoYXQgYXJlIGFsc28gZm91bmQgb25cbiAqIGBQcm9taXNlLnByb3RvdHlwZWAsIHNvIHRoYXQgb3ZlcnJpZGVzIG9mIHRoZXNlIHByb3BlcnRpZXMgY2FuIGJlXG4gKiBleHBsaWNpdGx5IHRvbGVyYXRlZCBpZiB0aGV5IHBhc3MgdGhlIGBjaGVja1NhZmVPd25LZXlgIGNoZWNrIGJlbG93LlxuICogSW4gcGFydGljdWxhciwgd2Ugd2lzaCB0byB0b2xlcmF0ZVxuICogICAqIEFuIG92ZXJyaWRpbmcgYHRvU3RyaW5nVGFnYCBub24tZW51bWVyYWJsZSBkYXRhIHByb3BlcnR5XG4gKiAgICAgd2l0aCBhIHN0cmluZyB2YWx1ZS5cbiAqICAgKiBUaG9zZSBvd24gcHJvcGVydGllcyB0aGF0IG1pZ2h0IGJlIGFkZGVkIGJ5IE5vZGUncyBhc3luY19ob29rcy5cbiAqL1xuY29uc3QgdW5rbm93bktleXM9a2V5cy5maWx0ZXIoXG4oa2V5KT0+dHlwZW9mIGtleSE9PSdzeW1ib2wnfHwhaGFzT3duUHJvcGVydHlPZihQcm9taXNlLnByb3RvdHlwZSxrZXkpKTtcblxuXG5pZih1bmtub3duS2V5cy5sZW5ndGghPT0wKXtcbnJldHVybiBDWChcbmNoZWNrKVxuIGAke3ByfSAtIE11c3Qgbm90IGhhdmUgYW55IG93biBwcm9wZXJ0aWVzOiAke3EodW5rbm93bktleXMpfWA7XG4gfVxuXG4vKipcbiAqIEV4cGxpY2l0bHkgdG9sZXJhdGUgYSBgdG9TdHJpbmdUYWdgIHN5bWJvbC1uYW1lZCBub24tZW51bWVyYWJsZVxuICogZGF0YSBwcm9wZXJ0eSB3aG9zZSB2YWx1ZSBpcyBhIHN0cmluZy4gT3RoZXJ3aXNlLCB0b2xlcmF0ZSB0aG9zZVxuICogc3ltYm9sLW5hbWVkIHByb3BlcnRpZXMgdGhhdCBtaWdodCBiZSBhZGRlZCBieSBOb2RlSlMncyBhc3luY19ob29rcyxcbiAqIGlmIHRoZXkgb2JleSB0aGUgZXhwZWN0ZWQgc2FmZXR5IHByb3BlcnRpZXMuXG4gKlxuICogQXQgdGhlIHRpbWUgb2YgdGhpcyB3cml0aW5nLCBOb2RlJ3MgYXN5bmNfaG9va3MgY29udGFpbnMgdGhlXG4gKiBmb2xsb3dpbmcgY29kZSwgd2hpY2ggd2UgY2FuIHNhZmVseSB0b2xlcmF0ZVxuICpcbiAqIGBgYGpzXG4gKiBmdW5jdGlvbiBkZXN0cm95VHJhY2tpbmcocHJvbWlzZSwgcGFyZW50KSB7XG4gKiAgIHRyYWNrUHJvbWlzZShwcm9taXNlLCBwYXJlbnQpO1xuICogICBjb25zdCBhc3luY0lkID0gcHJvbWlzZVthc3luY19pZF9zeW1ib2xdO1xuICogICBjb25zdCBkZXN0cm95ZWQgPSB7IGRlc3Ryb3llZDogZmFsc2UgfTtcbiAqICAgcHJvbWlzZVtkZXN0cm95ZWRTeW1ib2xdID0gZGVzdHJveWVkO1xuICogICByZWdpc3RlckRlc3Ryb3lIb29rKHByb21pc2UsIGFzeW5jSWQsIGRlc3Ryb3llZCk7XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGtleVxuICovXG5jb25zdCBjaGVja1NhZmVPd25LZXk9KGtleSk9PntcbmlmKGtleT09PXRvU3RyaW5nVGFnKXtcbi8qIFRPRE8gc2hvdWxkIHdlIGFsc28gZW5mb3JjZSBhbnl0aGluZyBvbiB0aGUgY29udGVudHMgb2YgdGhlIHN0cmluZywqL1xuLyogc3VjaCBhcyB0aGF0IGl0IG11c3Qgc3RhcnQgd2l0aCBgJ1Byb21pc2UnYD8qL1xuY29uc3QgdGFnRGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IocHIsdG9TdHJpbmdUYWcpO1xuYXNzZXJ0KHRhZ0Rlc2MhPT11bmRlZmluZWQpO1xucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YodGFnRGVzYywndmFsdWUnKXx8XG5DWChcbmNoZWNrKVxuIGBPd24gQEB0b1N0cmluZ1RhZyBtdXN0IGJlIGEgZGF0YSBwcm9wZXJ0eSwgbm90IGFuIGFjY2Vzc29yOiAke3EodGFnRGVzYyl9YCkmJihcbnR5cGVvZiB0YWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxuQ1goXG5jaGVjaylcbiBgT3duIEBAdG9TdHJpbmdUYWcgdmFsdWUgbXVzdCBiZSBhIHN0cmluZzogJHtxKHRhZ0Rlc2MudmFsdWUpfWApJiYoXG4hdGFnRGVzYy5lbnVtZXJhYmxlfHxcbkNYKGNoZWNrKSBgT3duIEBAdG9TdHJpbmdUYWcgbXVzdCBub3QgYmUgZW51bWVyYWJsZTogJHtxKHRhZ0Rlc2MpfWApKTtcblxuIH1cbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBDWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YDtcbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVPd25LZXkpO1xuIH07XG5cbi8qKlxuICogVW5kZXIgSGFyZGVuZWQgSlMgYSBwcm9taXNlIGlzIFwic2FmZVwiIGlmIGl0cyBgdGhlbmAgbWV0aG9kIGNhbiBiZSBjYWxsZWRcbiAqIHN5bmNocm9ub3VzbHkgd2l0aG91dCBnaXZpbmcgdGhlIHByb21pc2UgYW4gb3Bwb3J0dW5pdHkgZm9yIGFcbiAqIHJlZW50cmFuY3kgYXR0YWNrIGR1cmluZyB0aGF0IGNhbGwuXG4gKlxuICogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85XG4gKiByYWlzZXMgdGhlIGlzc3VlIG9mIHRlc3RpbmcgdGhhdCBhIHNwZWNpbWVuIGlzIGEgc2FmZSBwcm9taXNlXG4gKiBzdWNoIHRoYXQgdGhlIHRlc3QgYWxzbyBkb2VzIG5vdCBnaXZlIHRoZSBzcGVjaW1lbiBhXG4gKiByZWVudHJhbmN5IG9wcG9ydHVuaXR5LiBUaGF0IGlzIHdlbGwgYmV5b25kIHRoZSBhbWJpdGlvbiBoZXJlLlxuICogVE9ETyBUaG91Z2ggaWYgd2UgZmlndXJlIG91dCBhIG5pY2Ugc29sdXRpb24sIGl0IG1pZ2h0IGJlIGdvb2QgdG9cbiAqIHVzZSBpdCBoZXJlIGFzIHdlbGwuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tTYWZlUHJvbWlzZT0ocHIsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxDWChjaGVjaykgYCR7cHJ9IC0gTXVzdCBiZSBmcm96ZW5gKSYmKFxuaXNQcm9taXNlKHByKXx8Q1goY2hlY2spIGAke3ByfSAtIE11c3QgYmUgYSBwcm9taXNlYCkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbkNYKGNoZWNrKSBgJHtwcn0gLSBNdXN0IGluaGVyaXQgZnJvbSBQcm9taXNlLnByb3RvdHlwZTogJHtxKFxuZ2V0UHJvdG90eXBlT2YocHIpKVxuIH1gKSYmXG5jaGVja1Byb21pc2VPd25LZXlzKC8qKiBAdHlwZSB7UHJvbWlzZX0gKi9wcixjaGVjaykpO1xuXG4gfTtcbmhhcmRlbihjaGVja1NhZmVQcm9taXNlKTtcblxuLyoqXG4gKiBEZXRlcm1pbmUgaWYgdGhlIGFyZ3VtZW50IGlzIGEgUHJvbWlzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHByIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7cHIgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHByb21pc2VcbiAqL1xuY29uc3QgICAgICAgIGlzU2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwciwoeCk9PngpOyRozY9fb25jZS5pc1NhZmVQcm9taXNlKGlzU2FmZVByb21pc2UpO1xuaGFyZGVuKGlzU2FmZVByb21pc2UpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0U2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwcixhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNTYWZlUHJvbWlzZSI6WyJpc1NhZmVQcm9taXNlIl0sImFzc2VydFNhZmVQcm9taXNlIjpbImFzc2VydFNhZmVQcm9taXNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3RyaW5nLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vudi1vcHRpb25zIiwiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLEZhaWw7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoga25vdyBhYm91dGBpc1dlbGxGb3JtZWRgKi9cbmNvbnN0IGhhc1dlbGxGb3JtZWRTdHJpbmdNZXRob2Q9ISFTdHJpbmcucHJvdG90eXBlLmlzV2VsbEZvcm1lZDtcblxuLyoqXG4gKiBJcyB0aGUgYXJndW1lbnQgYSB3ZWxsLWZvcm1lZCBzdHJpbmc/XG4gKlxuICogVW5mb3J0dW5hdGVseSwgdGhlXG4gKiBbc3RhbmRhcmQgYnVpbHQtaW4gYFN0cmluZy5wcm90b3R5cGUuaXNXZWxsRm9ybWVkYF0oaHR0cHM6Ly9naXRodWIuY29tL3RjMzkvcHJvcG9zYWwtaXMtdXN2LXN0cmluZylcbiAqIGRvZXMgYSBUb1N0cmluZyBvbiBpdHMgaW5wdXQsIGNhdXNpbmcgaXQgdG8ganVkZ2Ugbm9uLXN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MgaWYgdGhleSBjb2VyY2UgdG8gYSB3ZWxsLWZvcm1lZCBzdHJpbmdzLiBUaGlzXG4gKiByZWNhcGl0dWxhdGVzIHRoZSBtaXN0YWtlIGluIGhhdmluZyB0aGUgZ2xvYmFsIGBpc05hTmAgY29lcmNlIGl0cyBpbnB1dHMsXG4gKiBjYXVzaW5nIGl0IHRvIGp1ZGdlIG5vbi1zdHJpbmcgdG8gYmUgTmFOIGlmIHRoZXkgY29lcmNlIHRvIE5hTi5cbiAqXG4gKiBUaGlzIGBpc1dlbGxGb3JtZWRTdHJpbmdgIGZ1bmN0aW9uIG9ubHkganVkZ2VzIHdlbGwtZm9ybWVkIHN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MuIEZvciBhbGwgbm9uLXN0cmluZ3MgaXQgcmV0dXJucyBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge3N0ciBpcyBzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBpc1dlbGxGb3JtZWRTdHJpbmc9aGFzV2VsbEZvcm1lZFN0cmluZ01ldGhvZD9cbihzdHIpPT50eXBlb2Ygc3RyPT09J3N0cmluZycmJnN0ci5pc1dlbGxGb3JtZWQoKTpcbihzdHIpPT57XG5pZih0eXBlb2Ygc3RyIT09J3N0cmluZycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmZvcihjb25zdCBjaCBvZiBzdHIpe1xuLyogVGhlIHN0cmluZyBpdGVyYXRvciBpdGVyYXRlcyBieSBVbmljb2RlIGNvZGUgcG9pbnQsIG5vdCovXG4vKiBVVEYxNiBjb2RlIHVuaXQuIEJ1dCBpZiBpdCBlbmNvdW50ZXJzIGFuIHVucGFpcmVkIHN1cnJvZ2F0ZSwqL1xuLyogaXQgd2lsbCBwcm9kdWNlIGl0LiovXG5jb25zdCBjcD0vKiogQHR5cGUge251bWJlcn0gKi9jaC5jb2RlUG9pbnRBdCgwKTtcbmlmKGNwPj0weGQ4MDAmJmNwPD0weGRmZmYpe1xuLyogQWxsIHN1cnJvZ2F0ZXMgYXJlIGluIHRoaXMgcmFuZ2UuIFRoZSBzdHJpbmcgaXRlcmF0b3Igb25seSovXG4vKiBwcm9kdWNlcyBhIGNoYXJhY3RlciBpbiB0aGlzIHJhbmdlIGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzLCovXG4vKiB3aGljaCBvbmx5IGhhcHBlbnMgaWYgdGhlIHN0cmluZyBpcyBub3Qgd2VsbC1mb3JtZWQuKi9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNXZWxsRm9ybWVkU3RyaW5nKGlzV2VsbEZvcm1lZFN0cmluZyk7XG5oYXJkZW4oaXNXZWxsRm9ybWVkU3RyaW5nKTtcblxuLyoqXG4gKiBSZXR1cm5zIG5vcm1hbGx5IHdoZW4gYGlzV2VsbEZvcm1lZFN0cmluZyhzdHIpYCB3b3VsZCByZXR1cm4gdHJ1ZS5cbiAqIFRocm93cyBhIGRpYWdub3N0aWMgZXJyb3Igd2hlbiBgaXNXZWxsRm9ybWVkU3RyaW5nKHN0cilgIHdvdWxkIHJldHVybiBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge2Fzc2VydHMgc3RyIGlzIHN0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFdlbGxGb3JtZWRTdHJpbmc9KHN0cik9PntcbmlzV2VsbEZvcm1lZFN0cmluZyhzdHIpfHxGYWlsIGBFeHBlY3RlZCB3ZWxsLWZvcm1lZCB1bmljb2RlIHN0cmluZzogJHtzdHJ9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRXZWxsRm9ybWVkU3RyaW5nKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuXG5jb25zdCBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEU9XG5nZXRFbnZpcm9ubWVudE9wdGlvbignT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFJywnZGlzYWJsZWQnLFtcbidlbmFibGVkJ10pPT09XG4nZW5hYmxlZCc7XG5cbi8qKlxuICogRm9yIG5vdyxcbiAqIGlmIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGVudmlyb25tZW50IG9wdGlvbiBpcyBgJ2VuYWJsZWQnYCxcbiAqIHRoZW4gYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBpcyB0aGUgc2FtZSBhcyBgYXNzZXJ0V2VsbEZvcm1lZFN0cmluZ2AuXG4gKiBPdGhlcndpc2UgYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBqdXN0IGFzc2VydHMgdGhhdCBgc3RyYCBpcyBhIHN0cmluZy5cbiAqXG4gKiBDdXJyZW50bHksIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGRlZmF1bHRzIHRvIGAnZGlzYWJsZWQnYFxuICogYmVjYXVzZSB3ZSBkbyBub3QgeWV0IGtub3cgdGhlIHBlcmZvcm1hbmNlIGltcGFjdC4gTGF0ZXIsIGlmIHdlIGRlY2lkZSB3ZVxuICogY2FuIGFmZm9yZCBpdCwgd2UnbGwgZmlyc3QgY2hhbmdlIHRoZSBkZWZhdWx0IHRvIGAnZW5hYmxlZCdgIGFuZCB1bHRpbWF0ZWx5XG4gKiByZW1vdmUgdGhlIHN3aXRjaCBhbHRvZ2V0aGVyLiBCZSBwcmVwYXJlZCBmb3IgdGhlc2UgY2hhbmdlcy5cbiAqXG4gKiBUT0RPIG9uY2UgdGhlIHN3aXRjaCBpcyByZW1vdmVkLCBzaW1wbGlmeSBgYXNzZXJ0UGFzc2FibGVTdHJpbmdgIHRvXG4gKiBzaW1wbHkgYmUgYGFzc2VydFdlbGxGb3JtZWRTdHJpbmdgLlxuICpcbiAqIEBwYXJhbSB7IHVua25vd24gfSBzdHJcbiAqIEByZXR1cm5zIHthc3NlcnRzIHN0ciBpcyBzdHJpbmcgfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTdHJpbmc9KHN0cik9PntcbnR5cGVvZiBzdHI9PT0nc3RyaW5nJ3x8RmFpbCBgRXhwZWN0ZWQgc3RyaW5nICR7c3RyfWA7XG4hT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFfHxhc3NlcnRXZWxsRm9ybWVkU3RyaW5nKHN0cik7XG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTdHJpbmcoYXNzZXJ0UGFzc2FibGVTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3RyaW5nKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzV2VsbEZvcm1lZFN0cmluZyI6WyJpc1dlbGxGb3JtZWRTdHJpbmciXSwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyI6WyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIl0sImFzc2VydFBhc3NhYmxlU3RyaW5nIjpbImFzc2VydFBhc3NhYmxlU3RyaW5nIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMs77KO4EgAAuBIAACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3ltYm9sLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjNj19vbmNlLmlzUGFzc2FibGVTeW1ib2woaXNQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oaXNQYXNzYWJsZVN5bWJvbCk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZVN5bWJvbD0oc3ltKT0+XG5pc1Bhc3NhYmxlU3ltYm9sKHN5bSl8fFxuRmFpbCBgT25seSByZWdpc3RlcmVkIHN5bWJvbHMgb3Igd2VsbC1rbm93biBzeW1ib2xzIGFyZSBwYXNzYWJsZTogJHtxKHN5bSl9YDskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTeW1ib2woYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3ltYm9sKTtcblxuLyoqXG4gKiBJZiBgc3ltYCBpcyBhIHBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGEgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzXG4gKiBzeW1ib2wuIElmIGBzeW1gIGlzIGEgbm9uLXBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGB1bmRlZmluZWRgLlxuICpcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuIFNpbmNlIHRoZSByZWdpc3RyYXRpb24gc3RyaW5nIG9mIGEgcmVnaXN0ZXJlZCBzeW1ib2wgY2FuIGJlIGFueVxuICogc3RyaW5nLCBpZiB3ZSBzaW1wbHkgdXNlZCB0aGF0IHRvIGlkZW50aWZ5IHRob3NlIHN5bWJvbHMsIHRoZXJlIHdvdWxkIG5vdFxuICogYmUgYW55IHJlbWFpbmluZyBzdHJpbmdzIGxlZnQgb3ZlciB0byBpZGVudGlmeSB0aGUgd2VsbC1rbm93biBzeW1ib2xzLlxuICogSW5zdGVhZCwgd2UgcmVzZXJ2ZSBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGBcIkBAXCJgIGZvciBwdXJwb3NlcyBvZiB0aGlzXG4gKiBlbmNvZGluZy4gV2UgaWRlbnRpZnkgYSB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiBieSBwcmVmaXhpbmcgdGhlIHByb3BlcnR5IG5hbWUgd2l0aCBgXCJAQFwiYCwgc3VjaCBhcyBgXCJAQGl0ZXJhdG9yXCJgLlxuICogRm9yIHJlZ2lzdGVyZWQgc3ltYm9scyB3aG9zZSBuYW1lIGhhcHBlbnMgdG8gYmVnaW4gd2l0aCBgXCJAQFwiYCwgc3VjaFxuICogYXMgYFN5bWJvbC5mb3IoJ0BAaXRlcmF0b3InKWAgb3IgYFN5bWJvbC5mb3IoJ0BAZm9vJylgLCB3ZSBpZGVudGlmeVxuICogdGhlbSBieSBwcmVmaXhpbmcgdGhlbSB3aXRoIGFuIGV4dHJhIGBcIkBAXCJgLCBzdWNoIGFzXG4gKiBgXCJAQEBAaXRlcmF0b3JcImAgb3IgYFwiQEBAQGZvb1wiYC4gKFRoaXMgaXMgdGhlIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmdcbiAqIHRlY2huaXF1ZS4pXG4gKlxuICogQHBhcmFtIHtzeW1ib2x9IHN5bVxuICogQHJldHVybnMge3N0cmluZz19XG4gKi9cbmNvbnN0ICAgICAgICBuYW1lRm9yUGFzc2FibGVTeW1ib2w9KHN5bSk9PntcbmNvbnN0IG5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYobmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gd2VsbEtub3duU3ltYm9sTmFtZXMuZ2V0KHN5bSk7XG4gfVxuaWYobmFtZS5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBgQEAke25hbWV9YDtcbiB9XG5yZXR1cm4gbmFtZTtcbiB9OyRozY9fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaM2PX29uY2UucGFzc2FibGVTeW1ib2xGb3JOYW1lKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG5oYXJkZW4ocGFzc2FibGVTeW1ib2xGb3JOYW1lKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUGFzc2FibGVTeW1ib2wiOlsiaXNQYXNzYWJsZVN5bWJvbCJdLCJhc3NlcnRQYXNzYWJsZVN5bWJvbCI6WyJhc3NlcnRQYXNzYWJsZVN5bWJvbCJdLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiOlsibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sInBhc3NhYmxlU3ltYm9sRm9yTmFtZSI6WyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADBplv5UIAACVCAAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90YWdnZWQuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlRhZ2dlZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxnZXRPd25EYXRhRGVzY3JpcHRvcixjaGVja1Bhc3NTdHlsZTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrVGFnUmVjb3JkID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXSxbXCJjaGVja1Bhc3NTdHlsZVwiLCBbJGjNj19hID0+IChjaGVja1Bhc3NTdHlsZSA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtJTVBPUlQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBUYWdnZWRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTondGFnZ2VkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuY2hlY2tQYXNzU3R5bGUoY2FuZGlkYXRlLGNhbmRpZGF0ZVtQQVNTX1NUWUxFXSwndGFnZ2VkJyxjaGVjayksXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNoZWNrVGFnUmVjb3JkKGNhbmRpZGF0ZSwndGFnZ2VkJyxhc3NlcnRDaGVja2VyKTtcblxuLyogVHlwZWNhc3RzIG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbmNvbnN0IHBhc3NTdHlsZUtleT0vKiogQHR5cGUge3Vua25vd259ICovUEFTU19TVFlMRTtcbmNvbnN0IHRhZ0tleT0vKiogQHR5cGUge3Vua25vd259ICovU3ltYm9sLnRvU3RyaW5nVGFnO1xuY29uc3R7XG4vKiBjaGVja1RhZ1JlY29yZCBhbHJlYWR5IHZlcmlmaWVkIFBBU1NfU1RZTEUgYW5kIFN5bWJvbC50b1N0cmluZ1RhZyBvd24gZGF0YSBwcm9wZXJ0aWVzLiovXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovcGFzc1N0eWxlS2V5XTpfcGFzc1N0eWxlRGVzYyxcblsvKiogQHR5cGUge3N0cmluZ30gKi90YWdLZXldOl9sYWJlbERlc2MsXG5wYXlsb2FkOl9wYXlsb2FkRGVzYywvKiB2YWx1ZSBjaGVja2VkIGJ5IHJlY3Vyc2l2ZSB3YWxrIGF0IHRoZSBlbmQqL1xuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg9PT0wfHxcbkZhaWwgYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiB0YWdnZWQgcmVjb3JkICR7b3duS2V5cyhyZXN0RGVzY3MpfWA7XG5cbi8qIFZhbGlkYXRlIHRoYXQgdGhlICdwYXlsb2FkJyBwcm9wZXJ0eSBpcyBvd24vZGF0YS9lbnVtZXJhYmxlKi9cbi8qIGFuZCBpdHMgYXNzb2NpYXRlZCB2YWx1ZSBpcyByZWN1cnNpdmVseSBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKS52YWx1ZSk7XG5cbiB9fSk7JGjNj19vbmNlLlRhZ2dlZEhlbHBlcihUYWdnZWRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKomXX/AsAAPwLAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEscGFzc1N0eWxlT2Y7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjNj19hID0+IChwYXNzU3R5bGVPZiA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoqIEBpbXBvcnQge0NvcHlBcnJheSwgQ29weVJlY29yZCwgUGFzc2FibGUsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHBhc3MtYnktY29weSBhcnJheSwgQUtBIGEgXCJjb3B5QXJyYXlcIlxuICogaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjNj19vbmNlLmlzQ29weUFycmF5KGlzQ29weUFycmF5KTtcbmhhcmRlbihpc0NvcHlBcnJheSk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBBS0EgYVxuICogXCJjb3B5UmVjb3JkXCIgaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaM2PX29uY2UuaXNSZWNvcmQoaXNSZWNvcmQpO1xuaGFyZGVuKGlzUmVjb3JkKTtcblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHJlbW90YWJsZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtyZW1vdGFibGUgaXMgUmVtb3RhYmxlT2JqZWN0fVxuICovXG5jb25zdCBpc1JlbW90YWJsZT0ocmVtb3RhYmxlKT0+cGFzc1N0eWxlT2YocmVtb3RhYmxlKT09PSdyZW1vdGFibGUnOyRozY9fb25jZS5pc1JlbW90YWJsZShpc1JlbW90YWJsZSk7XG5oYXJkZW4oaXNSZW1vdGFibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaM2PX29uY2UuYXNzZXJ0Q29weUFycmF5KGFzc2VydENvcHlBcnJheSk7XG5oYXJkZW4oYXNzZXJ0Q29weUFycmF5KTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuY29uc3QgYXNzZXJ0UmVjb3JkPShyZWNvcmQsb3B0TmFtZU9mUmVjb3JkPSdBbGxlZ2VkIHJlY29yZCcpPT57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVjb3JkKTtcbnBhc3NTdHlsZT09PSdjb3B5UmVjb3JkJ3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mUmVjb3JkKX0gJHtyZWNvcmR9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBub3QgJHtxKFxucGFzc1N0eWxlKVxuIH1gO1xuIH07JGjNj19vbmNlLmFzc2VydFJlY29yZChhc3NlcnRSZWNvcmQpO1xuaGFyZGVuKGFzc2VydFJlY29yZCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlbW90YWJsZVxuICogQHJldHVybnMge2Fzc2VydHMgcmVtb3RhYmxlIGlzIFJlbW90YWJsZU9iamVjdH1cbiAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRSZW1vdGFibGUoYXNzZXJ0UmVtb3RhYmxlKTtcbmhhcmRlbihhc3NlcnRSZW1vdGFibGUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5QXJyYXkiOlsiaXNDb3B5QXJyYXkiXSwiaXNSZWNvcmQiOlsiaXNSZWNvcmQiXSwiaXNSZW1vdGFibGUiOlsiaXNSZW1vdGFibGUiXSwiYXNzZXJ0Q29weUFycmF5IjpbImFzc2VydENvcHlBcnJheSJdLCJhc3NlcnRSZWNvcmQiOlsiYXNzZXJ0UmVjb3JkIl0sImFzc2VydFJlbW90YWJsZSI6WyJhc3NlcnRSZW1vdGFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA7PqD1JMJAACTCQAAIQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsIi4vc3JjL21lbW8tcmFjZS5qcyIsIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VQcm9taXNlS2l0IiwicmFjZVByb21pc2VzIl0sInJlZXhwb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0LG1lbW9SYWNlOyRozY9faW1wb3J0cyhbW1wiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNcIiwgW1tcIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdFwiLCBbJGjNj19hID0+IChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQgPSAkaM2PX2EpXV1dXSxbXCIuL3NyYy9tZW1vLXJhY2UuanNcIiwgW1tcIm1lbW9SYWNlXCIsIFskaM2PX2EgPT4gKG1lbW9SYWNlID0gJGjNj19hKV1dXV0sW1wiLi9zcmMvaXMtcHJvbWlzZS5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VQcm9taXNlS2l0LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlUHJvbWlzZUtpdFwifSk7JGjNj19vbmNlLm1ha2VQcm9taXNlS2l0KG1ha2VQcm9taXNlS2l0KTtPYmplY3QuZGVmaW5lUHJvcGVydHkocmFjZVByb21pc2VzLCAnbmFtZScsIHt2YWx1ZTogXCJyYWNlUHJvbWlzZXNcIn0pOyRozY9fb25jZS5yYWNlUHJvbWlzZXMocmFjZVByb21pc2VzKTsgICBcblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gKi9cbmNvbnN0IEJlc3RQaXBlbGluYWJsZVByb21pc2U9Z2xvYmFsVGhpcy5IYW5kbGVkUHJvbWlzZXx8UHJvbWlzZTtcblxuLyoqXG4gKiBtYWtlUHJvbWlzZUtpdCgpIGJ1aWxkcyBhIFByb21pc2Ugb2JqZWN0LCBhbmQgcmV0dXJucyBhIHJlY29yZFxuICogY29udGFpbmluZyB0aGUgcHJvbWlzZSBpdHNlbGYsIGFzIHdlbGwgYXMgc2VwYXJhdGUgZmFjZXRzIGZvciByZXNvbHZpbmdcbiAqIGFuZCByZWplY3RpbmcgaXQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtJTVBPUlQoJy4vc3JjL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPn1cbiAqL1xuZnVuY3Rpb24gICAgICAgIG1ha2VQcm9taXNlS2l0KCl7XG5jb25zdHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn09bWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCk7XG5cbmNvbnN0IHByb21pc2U9bmV3IEJlc3RQaXBlbGluYWJsZVByb21pc2UoZXhlY3V0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtwcm9taXNlLHJlc29sdmUscmVqZWN0fSk7XG4gfVxuaGFyZGVuKG1ha2VQcm9taXNlS2l0KTtcblxuLyogTkI6IEFub3RoZXIgaW1wbGVtZW50YXRpb24gZm9yIFByb21pc2UucmFjZSB3b3VsZCBiZSB0byB1c2UgdGhlIHJlbGVhc2luZyBleGVjdXRvciwqL1xuLyogSG93ZXZlciB3aGlsZSBpdCB3b3VsZCBubyBsb25nZXIgbGVhayB0aGUgcmFjZWQgcHJvbWlzZSBvYmplY3RzIHRoZW1zZWx2ZXMsIGl0IHdvdWxkKi9cbi8qIHN0aWxsIGxlYWsgcmVhY3Rpb25zIG9uIHRoZSBub24tcmVzb2x2ZWQgcHJvbWlzZXMgY29udGVuZGluZyBmb3IgdGhlIHJhY2UuKi9cblxuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5mdW5jdGlvbiAgICAgICAgcmFjZVByb21pc2VzKHZhbHVlcyl7XG5yZXR1cm4gaGFyZGVuKG1lbW9SYWNlLmNhbGwoQmVzdFBpcGVsaW5hYmxlUHJvbWlzZSx2YWx1ZXMpKTtcbiB9XG5oYXJkZW4ocmFjZVByb21pc2VzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlS2l0IjpbIm1ha2VQcm9taXNlS2l0Il0sInJhY2VQcm9taXNlcyI6WyJyYWNlUHJvbWlzZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvaXMtcHJvbWlzZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiaXNQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNQcm9taXNlLCAnbmFtZScsIHt2YWx1ZTogXCJpc1Byb21pc2VcIn0pOyRozY9fb25jZS5pc1Byb21pc2UoaXNQcm9taXNlKTsgICAvKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gbWF5YmVQcm9taXNlIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7bWF5YmVQcm9taXNlIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmZ1bmN0aW9uICAgICAgICBpc1Byb21pc2UobWF5YmVQcm9taXNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUobWF5YmVQcm9taXNlKT09PW1heWJlUHJvbWlzZTtcbiB9XG5oYXJkZW4oaXNQcm9taXNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJvbWlzZSI6WyJpc1Byb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAASLuyqBcTAAAXEwAAKQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtZW1vUmFjZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgLyogSW5pdGlhbCB2ZXJzaW9uIGF1dGhvcmVkIGJ5IEJyaWFuIEtpbTpcbmh0dHBzOi8vZ2l0aHViLmNvbS9ub2RlanMvbm9kZS9pc3N1ZXMvMTc0NjkjaXNzdWVjb21tZW50LTY4NTIxNjc3N1xuIFRoaXMgaXMgZnJlZSBhbmQgdW5lbmN1bWJlcmVkIHNvZnR3YXJlIHJlbGVhc2VkIGludG8gdGhlIHB1YmxpYyBkb21haW4uXG4gQW55b25lIGlzIGZyZWUgdG8gY29weSwgbW9kaWZ5LCBwdWJsaXNoLCB1c2UsIGNvbXBpbGUsIHNlbGwsIG9yXG5kaXN0cmlidXRlIHRoaXMgc29mdHdhcmUsIGVpdGhlciBpbiBzb3VyY2UgY29kZSBmb3JtIG9yIGFzIGEgY29tcGlsZWRcbmJpbmFyeSwgZm9yIGFueSBwdXJwb3NlLCBjb21tZXJjaWFsIG9yIG5vbi1jb21tZXJjaWFsLCBhbmQgYnkgYW55XG5tZWFucy5cbiBJbiBqdXJpc2RpY3Rpb25zIHRoYXQgcmVjb2duaXplIGNvcHlyaWdodCBsYXdzLCB0aGUgYXV0aG9yIG9yIGF1dGhvcnNcbm9mIHRoaXMgc29mdHdhcmUgZGVkaWNhdGUgYW55IGFuZCBhbGwgY29weXJpZ2h0IGludGVyZXN0IGluIHRoZVxuc29mdHdhcmUgdG8gdGhlIHB1YmxpYyBkb21haW4uIFdlIG1ha2UgdGhpcyBkZWRpY2F0aW9uIGZvciB0aGUgYmVuZWZpdFxub2YgdGhlIHB1YmxpYyBhdCBsYXJnZSBhbmQgdG8gdGhlIGRldHJpbWVudCBvZiBvdXIgaGVpcnMgYW5kXG5zdWNjZXNzb3JzLiBXZSBpbnRlbmQgdGhpcyBkZWRpY2F0aW9uIHRvIGJlIGFuIG92ZXJ0IGFjdCBvZlxucmVsaW5xdWlzaG1lbnQgaW4gcGVycGV0dWl0eSBvZiBhbGwgcHJlc2VudCBhbmQgZnV0dXJlIHJpZ2h0cyB0byB0aGlzXG5zb2Z0d2FyZSB1bmRlciBjb3B5cmlnaHQgbGF3LlxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsXG5FWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Zcbk1FUkNIQU5UQUJJTElUWSwgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC5cbklOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SXG5PVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSxcbkFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUlxuT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLlxuIEZvciBtb3JlIGluZm9ybWF0aW9uLCBwbGVhc2UgcmVmZXIgdG8gPGh0dHA6Ly91bmxpY2Vuc2Uub3JnLz5cbiovXG5cblxuXG5cblxuXG5cbmNvbnN0IGlzT2JqZWN0PSh2YWx1ZSk9Pk9iamVjdCh2YWx1ZSk9PT12YWx1ZTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgW1Q9YW55XVxuICogQHR5cGVkZWYge29iamVjdH0gRGVmZXJyZWRcbiAqIEBwcm9wZXJ0eSB7KHZhbHVlPzogSU1QT1JUKFwiLi90eXBlcy5qc1wiKS5FUmVmPFQ+ICkgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHByb3BlcnR5IHsoZXJyPzogYW55ICkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IG5ldmVyXG4gKiAgfCB7c2V0dGxlZDogZmFsc2UsIGRlZmVycmVkczogU2V0PERlZmVycmVkPn1cbiAqICB8IHtzZXR0bGVkOiB0cnVlLCBkZWZlcnJlZHM/OiB1bmRlZmluZWR9XG4gKiB9IFByb21pc2VNZW1vUmVjb3JkXG4gKi9cblxuLyogS2V5cyBhcmUgdGhlIHZhbHVlcyBwYXNzZWQgdG8gcmFjZSwgdmFsdWVzIGFyZSBhIHJlY29yZCBvZiBkYXRhIGNvbnRhaW5pbmcgYSovXG4vKiBzZXQgb2YgZGVmZXJyZWRzIGFuZCB3aGV0aGVyIHRoZSB2YWx1ZSBoYXMgc2V0dGxlZC4qL1xuLyoqIEB0eXBlIHtXZWFrTWFwPG9iamVjdCwgUHJvbWlzZU1lbW9SZWNvcmQ+fSAqL1xuY29uc3Qga25vd25Qcm9taXNlcz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZU1lbW9SZWNvcmQgfCB1bmRlZmluZWR9IHJlY29yZFxuICogQHJldHVybnMge1NldDxEZWZlcnJlZD59XG4gKi9cbmNvbnN0IG1hcmtTZXR0bGVkPShyZWNvcmQpPT57XG5pZighcmVjb3JkfHxyZWNvcmQuc2V0dGxlZCl7XG5yZXR1cm4gbmV3IFNldCgpO1xuIH1cblxuY29uc3R7ZGVmZXJyZWRzfT1yZWNvcmQ7XG5PYmplY3QuYXNzaWduKHJlY29yZCx7XG5kZWZlcnJlZHM6dW5kZWZpbmVkLFxuc2V0dGxlZDp0cnVlfSk7XG5cbk9iamVjdC5mcmVlemUocmVjb3JkKTtcbnJldHVybiBkZWZlcnJlZHM7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcmV0dXJucyB7UHJvbWlzZU1lbW9SZWNvcmR9XG4gKi9cbmNvbnN0IGdldE1lbW9SZWNvcmQ9KHZhbHVlKT0+e1xuaWYoIWlzT2JqZWN0KHZhbHVlKSl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIGEgcHJpbWl0aXZlLCBhdHRlbXB0aW5nIHRvIHVzZSBpdCBhcyBhIGtleSBpbiB0aGUqL1xuLyogd2Vha21hcCB3b3VsZCB0aHJvdyBhbiBlcnJvci4gTHVja2lseSwgaXQgaXMgc2FmZSB0byBjYWxsKi9cbi8qIGBQcm9taXNlLnJlc29sdmUoY29udGVuZGVyKS50aGVuYCBvbiBhIHByaW1pdGl2ZSB2YWx1ZSBtdWx0aXBsZSB0aW1lcyovXG4vKiBiZWNhdXNlIHRoZSBwcm9taXNlIGZ1bGZpbGxzIGltbWVkaWF0ZWx5LiBTbyB3ZSBmYWtlIGEgc2V0dGxlZCByZWNvcmQuKi9cbnJldHVybiBoYXJkZW4oe3NldHRsZWQ6dHJ1ZX0pO1xuIH1cblxubGV0IHJlY29yZD1rbm93blByb21pc2VzLmdldCh2YWx1ZSk7XG5cbmlmKCFyZWNvcmQpe1xucmVjb3JkPXtkZWZlcnJlZHM6bmV3IFNldCgpLHNldHRsZWQ6ZmFsc2V9O1xua25vd25Qcm9taXNlcy5zZXQodmFsdWUscmVjb3JkKTtcbi8qIFRoaXMgY2FsbCB0byBgdGhlbmAgaGFwcGVucyBvbmNlIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIHZhbHVlLiovXG5Qcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW4oXG4odmFsKT0+e1xuZm9yKGNvbnN0e3Jlc29sdmV9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZXNvbHZlKHZhbCk7XG4gfVxuIH0sXG4oZXJyKT0+e1xuZm9yKGNvbnN0e3JlamVjdH1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlamVjdChlcnIpO1xuIH1cbiB9KTtcblxuIH1cbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3R7cmFjZX09e1xuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHRlbXBsYXRlIHtQcm9taXNlQ29uc3RydWN0b3J9IFtQPVByb21pc2VDb25zdHJ1Y3Rvcl1cbiAqIEB0aGlzIHtQfVxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5yYWNlKHZhbHVlcyl7XG5sZXQgZGVmZXJyZWQ7XG4vKiogQHR5cGUge1suLi5UXX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgZmlsbGVkIGJ5IHRoZSBsb29wKi9cbmNvbnN0IGNhY2hlZFZhbHVlcz1bXTtcbmNvbnN0IEM9dGhpcztcbmNvbnN0IHJlc3VsdD1uZXcgQygocmVzb2x2ZSxyZWplY3QpPT57XG5kZWZlcnJlZD17cmVzb2x2ZSxyZWplY3R9O1xuZm9yKGNvbnN0IHZhbHVlIG9mIHZhbHVlcyl7XG5jYWNoZWRWYWx1ZXMucHVzaCh2YWx1ZSk7XG5jb25zdHtzZXR0bGVkLGRlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihzZXR0bGVkKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgc2V0dGxlZCAoaW5jbHVkaW5nIHByaW1pdGl2ZXMpLCBpdCBpcyBzYWZlKi9cbi8qIHRvIGNhbGwgYFByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbmAgb24gaXQuKi9cbkMucmVzb2x2ZSh2YWx1ZSkudGhlbihyZXNvbHZlLHJlamVjdCk7XG4gfWVsc2V7XG5kZWZlcnJlZHMuYWRkKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuXG4vKiBUaGUgZmluYWxseSBjYWxsYmFjayBleGVjdXRlcyB3aGVuIGFueSB2YWx1ZSBzZXR0bGVzLCBwcmV2ZW50aW5nIGFueSBvZiovXG4vKiB0aGUgdW5yZXNvbHZlZCB2YWx1ZXMgZnJvbSByZXRhaW5pbmcgYSByZWZlcmVuY2UgdG8gdGhlIHJlc29sdmVkIHZhbHVlLiovXG5yZXR1cm4gcmVzdWx0LmZpbmFsbHkoKCk9PntcbmZvcihjb25zdCB2YWx1ZSBvZiBjYWNoZWRWYWx1ZXMpe1xuY29uc3R7ZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKGRlZmVycmVkcyl7XG5kZWZlcnJlZHMuZGVsZXRlKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuIH19OyRozY9fb25jZS5yYWNlKHJhY2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWVtb1JhY2UiOlsicmFjZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACnhwxnegcAAHoHAAA0AAAAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAY2FsbGJhY2sgUHJvbWlzZUV4ZWN1dG9yIFRoZSBwcm9taXNlIGV4ZWN1dG9yXG4gKiBAcGFyYW0geyh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCkgYnVpbGRzIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyB3aGljaCBkcm9wIHJlZmVyZW5jZXNcbiAqIHRvIHRoZSByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgZ2F0aGVyZWQgZnJvbSBhbiBleGVjdXRvciB0byBiZSB1c2VkIHdpdGggYVxuICogcHJvbWlzZSBjb25zdHJ1Y3Rvci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1BpY2s8SU1QT1JUKCcuL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPiwgJ3Jlc29sdmUnIHwgJ3JlamVjdCc+ICYgeyBleGVjdXRvcjogUHJvbWlzZUV4ZWN1dG9yPFQ+fX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdD0oKT0+e1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKCh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZXNvbHZlO1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKChyZWFzb246IHVua25vd24pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVqZWN0O1xuXG4vKiogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+fSB2YWx1ZSAqL1xuY29uc3QgcmVzb2x2ZT0odmFsdWUpPT57XG5pZihpbnRlcm5hbFJlc29sdmUpe1xuaW50ZXJuYWxSZXNvbHZlKHZhbHVlKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT1udWxsKTtcbiB9XG4gfTtcblxuLyoqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uICovXG5jb25zdCByZWplY3Q9KHJlYXNvbik9PntcbmlmKGludGVybmFsUmVqZWN0KXtcbmludGVybmFsUmVqZWN0KHJlYXNvbik7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZWplY3Q9PT1udWxsKTtcbiB9XG4gfTtcblxuY29uc3QgZXhlY3V0b3I9KHJlcyxyZWopPT57XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09dW5kZWZpbmVkJiZpbnRlcm5hbFJlamVjdD09PXVuZGVmaW5lZCk7XG5pbnRlcm5hbFJlc29sdmU9cmVzO1xuaW50ZXJuYWxSZWplY3Q9cmVqO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfSk7XG4gfTskaM2PX29uY2UubWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG5oYXJkZW4obWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPdl043JBQAAyQUAAC0AAABAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy9kZW1vL3JhZy92YXRzL3dpa2kuanN7ImltcG9ydHMiOlsiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImJ1aWxkUm9vdE9iamVjdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYXI7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJGYXJcIiwgWyRozY9fYSA9PiAoRmFyID0gJGjNj19hKV1dXV1dKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoYnVpbGRSb290T2JqZWN0LCAnbmFtZScsIHt2YWx1ZTogXCJidWlsZFJvb3RPYmplY3RcIn0pOyRozY9fb25jZS5idWlsZFJvb3RPYmplY3QoYnVpbGRSb290T2JqZWN0KTsgICBcblxuLyoqXG4gKiBCdWlsZCBmdW5jdGlvbiBmb3IgdGhlIExMTSB0ZXN0IHZhdC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHZhdFBvd2VycyAtIFNwZWNpYWwgcG93ZXJzIGdyYW50ZWQgdG8gdGhpcyB2YXQgKG5vdCB1c2VkIGhlcmUpLlxuICogQHBhcmFtIHt1bmtub3dufSB2YXRQb3dlcnMudmVjdG9yU3RvcmUgLSBBIHZlY3RvclN0b3JlIHBvd2VyLlxuICogQHBhcmFtIHt1bmtub3dufSBwYXJhbWV0ZXJzIC0gSW5pdGlhbGl6YXRpb24gcGFyYW1ldGVycyBmcm9tIHRoZSB2YXQncyBjb25maWcgb2JqZWN0LlxuICogQHBhcmFtIHt1bmtub3dufSBfYmFnZ2FnZSAtIFJvb3Qgb2YgdmF0J3MgcGVyc2lzdGVudCBzdGF0ZSAobm90IHVzZWQgaGVyZSkuXG4gKiBAcmV0dXJucyB7dW5rbm93bn0gVGhlIHJvb3Qgb2JqZWN0IGZvciB0aGUgbmV3IHZhdC5cbiAqL1xuZnVuY3Rpb24gICAgICAgIGJ1aWxkUm9vdE9iamVjdCh2YXRQb3dlcnMscGFyYW1ldGVycyxfYmFnZ2FnZSl7XG5jb25zdHt2ZWN0b3JTdG9yZX09dmF0UG93ZXJzO1xuY29uc3R7ZG9jc309cGFyYW1ldGVycztcblxuY29uc29sZS5sb2coJ0RPQ1M6Jyxkb2NzKTtcblxuY29uc3QgaW5pdFZlY3RvclN0b3JlUD12ZWN0b3JTdG9yZS5hZGREb2N1bWVudHMoWy4uLmRvY3NdKTtcblxucmV0dXJuIEZhcigncm9vdCcse1xuICAgICAgYXN5bmMgcmV0cmlldmUodG9waWMpe1xuYXdhaXQgaW5pdFZlY3RvclN0b3JlUDtcbi8qIFNlYXJjaCBmb3IgdGhlIG1vc3Qgc2ltaWxhciBkb2N1bWVudCovXG5jb25zdCByZXN1bHQ9YXdhaXQgdmVjdG9yU3RvcmUuc2ltaWxhcml0eVNlYXJjaCh0b3BpYywxKTtcbmNvbnNvbGUubG9nKCdSZXRyaWV2ZSBnb3QnLHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH19KTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImJ1aWxkUm9vdE9iamVjdCI6WyJidWlsZFJvb3RPYmplY3QiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAQIeAwoAAAAAAAAAAAAkLaOZCzsAAAs7AAAUAAAAAAAAAAAAAACkgQAAAABjb21wYXJ0bWVudC1tYXAuanNvblBLAQIeAwoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAAAAAAAAAAACkgT07AABAZW5kby9jb21tb24tdjEuMi44L29iamVjdC1tYXAuanNQSwECHgMKAAAAAAAAAAAAxRjnOpQBAACUAQAAIQAAAAAAAAAAAAAApIG5RQAAQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAF2blOoeEwAAHhMAACsAAAAAAAAAAAAAAKSBjEcAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanNQSwECHgMKAAAAAAAAAAAA54weVukMAADpDAAAHAAAAAAAAAAAAAAApIHzWgAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAAAAAAAAAAACkgRZoAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvRS5qc1BLAQIeAwoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAAAAAAAAAAACkgaiiAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvZXhwb3J0cy5qc1BLAQIeAwoAAAAAAAAAAABtsJ5smBEAAJgRAAAnAAAAAAAAAAAAAACkgTmkAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanNQSwECHgMKAAAAAAAAAAAAbfEwFqEWAAChFgAANQAAAAAAAAAAAAAApIEWtgAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNQSwECHgMKAAAAAAAAAAAAF4RTDHkDAAB5AwAAKQAAAAAAAAAAAAAApIEKzQAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL25vLXNoaW0uanNQSwECHgMKAAAAAAAAAAAAHrjny+0QAADtEAAALQAAAAAAAAAAAAAApIHK0AAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL3RyYWNrLXR1cm5zLmpzUEsBAh4DCgAAAAAAAAAAAD/w5zpWAgAAVgIAACMAAAAAAAAAAAAAAKSBAuIAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3V0aWxzLmpzUEsBAh4DCgAAAAAAAAAAALiBafB0BwAAdAcAAB0AAAAAAAAAAAAAAKSBmeQAAEBlbmRvL21hcnNoYWwtdjEuNi4yL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAAAAAAAAAAAAAKSBSOwAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1BLAQIeAwoAAAAAAAAAAAAxiq7kSjoAAEo6AAArAAAAAAAAAAAAAACkgVtcAQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzUEsBAh4DCgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAAAAAAAAAAAAAKSB7pYBAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qc1BLAQIeAwoAAAAAAAAAAABwTp8yYSwAAGEsAAAqAAAAAAAAAAAAAACkgeTSAQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvbWFyc2hhbC1qdXN0aW4uanNQSwECHgMKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAAAAAAAAAAAApIGN/wEAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzUEsBAh4DCgAAAAAAAAAAABOxXN6ZNwAAmTcAACMAAAAAAAAAAAAAAKSB8gYCAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzUEsBAh4DCgAAAAAAAAAAAGa7QcrbQQAA20EAACUAAAAAAAAAAAAAAKSBzD4CAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAAAAAAAAAAAApIHqgAIAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAGovdarWCwAA1gsAAB4AAAAAAAAAAAAAAKSBc4ICAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAChKaq8PwoAAD8KAAAgAAAAAAAAAAAAAACkgYWOAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAB5gH8MAwgAAAMIAAAoAAAAAAAAAAAAAACkgQKZAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvY29weUFycmF5LmpzUEsBAh4DCgAAAAAAAAAAAKx1kaFJCgAASQoAACkAAAAAAAAAAAAAAKSBS6ECAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzUEsBAh4DCgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAAAAAAAAAAAAAKSB26sCAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9kZWVwbHlGdWxmaWxsZWQuanNQSwECHgMKAAAAAAAAAAAAURL94C4bAAAuGwAAJAAAAAAAAAAAAAAApIFLwQIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzUEsBAh4DCgAAAAAAAAAAALuYdZNnCAAAZwgAACsAAAAAAAAAAAAAAKSBu9wCAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAA3mPGmlwkAABcJAAAJwAAAAAAAAAAAAAApIFr5QIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL21ha2UtZmFyLmpzUEsBAh4DCgAAAAAAAAAAABlaIjoeBQAAHgUAACkAAAAAAAAAAAAAAKSBDAoDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAAAAAAAAAAAAAKSBcQ8DAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAAAAAAAAAAACkgdorAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlT2YuanNQSwECHgMKAAAAAAAAAAAAguQCxxIiAAASIgAAKAAAAAAAAAAAAAAApIGaYgMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc1BLAQIeAwoAAAAAAAAAAAAERhXGuhQAALoUAAArAAAAAAAAAAAAAACkgfKEAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAAAAAAAAAAAAAKSB9ZkDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9zdHJpbmcuanNQSwECHgMKAAAAAAAAAAAAyzvso7gSAAC4EgAAJQAAAAAAAAAAAAAApIFMqQMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3N5bWJvbC5qc1BLAQIeAwoAAAAAAAAAAAAMGmW/lQgAAJUIAAAlAAAAAAAAAAAAAACkgUe8AwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvdGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAAqiZdf8CwAA/AsAACkAAAAAAAAAAAAAAKSBH8UDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAAS6w5NKAQAASgEAACQAAAAAAAAAAAAAAKSBYtEDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAADs+oPUkwkAAJMJAAAhAAAAAAAAAAAAAACkge7SAwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAAAAAAAAAAAApIHA3AMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9pcy1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAEi7sqgXEwAAFxMAACkAAAAAAAAAAAAAAKSB/N8DAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzUEsBAh4DCgAAAAAAAAAAAKeHDGd6BwAAegcAADQAAAAAAAAAAAAAAKSBWvMDAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAAAAAAAAAAAApIEm+wMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAD3ZdONyQUAAMkFAAAtAAAAAAAAAAAAAACkgbP8AwBAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy9kZW1vL3JhZy92YXRzL3dpa2kuanNQSwUGAAAAAC0ALQDyDgAAxwIEAAAA","endoZipBase64Sha512":"b8c9f88d049eba666aeb7f824c707e2379046a81f6d450ae44bf74716ba6b4aa4d7de93773ccb5d7038ae405f77852542cfe60b67f4b4d0c41dd14e100b83627"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"c0ade7f01dc81c1b3608ac033ba9671aa9cdb55437515971c7a0780588bfb9d01ed5e36a914ce6b720f018033e7df29a47eb05dc0612b7cfb0b82234983ec3e7"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/wiki.js b/packages/nodejs/src/demo/rag/vats/wiki.js index 4eddb8e8f..05eecd215 100644 --- a/packages/nodejs/src/demo/rag/vats/wiki.js +++ b/packages/nodejs/src/demo/rag/vats/wiki.js @@ -10,20 +10,27 @@ import { Far } from '@endo/marshal'; * @returns {unknown} The root object for the new vat. */ export function buildRootObject(vatPowers, parameters, _baggage) { - const { vectorStore } = vatPowers; - const { docs } = parameters; - - console.log('DOCS:', docs); - - const initVectorStoreP = vectorStore.addDocuments([...docs]); + const { model } = parameters; + const { getVectorStore, ollama } = vatPowers; + const vectorStore = getVectorStore(); return Far('root', { + async initModels() { + await ollama.pull({ model }); + }, + async addDocuments(docs) { + console.time('wiki.addDocuments'); + await vectorStore.addDocuments(docs); + console.timeEnd('wiki.addDocuments'); + }, async retrieve(topic) { - await initVectorStoreP; - // Search for the most similar document - const result = await vectorStore.similaritySearch(topic, 1); - console.log('Retrieve got', result); - return result; + // Search for the most similar documents + const results = await vectorStore.similaritySearch(topic, 3); + console.log('Retrieve got', results); + return results.map((document) => ({ + pageContent: document.pageContent, + metadata: { source: document.metadata.source }, + })); }, }); } diff --git a/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt b/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt index 350b6d943..341e93e35 100644 --- a/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt +++ b/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt @@ -3,34 +3,6 @@ == Definition == A subject, such as a computer program, is said to be using ''ambient authority'' if it only needs to specify the names of the involved object(s) and the operation to be performed on them in order for a permitted action to succeed. -{{cite journal - | last1=Miller | first1=Mark S. - | last2=Yee | first2=Ka-Ping - | last3=Shapiro | first3=Jonathan - | title=Capability Myths Demolished - | year=2003 - | url=http://www.cs.umd.edu/~jkatz/security/downloads/capability-myths.pdf -}} -{{cite mailing list - |last = Donnelley - |first = Jed - |title = [cap-talk] ... enforcement - ambient authority - definition? - |mailing-list = cap-talk - |date = 6 October 2004 - |url = http://www.eros-os.org/pipermail/cap-talk/2004-October/002001.html - |access-date = June 28, 2012 - |archive-url = https://archive.today/20130414191435/http://www.eros-os.org/pipermail/cap-talk/2004-October/002001.html - |archive-date = 2013-04-14 - |url-status = dead -}} -{{cite mailing list - | last =Tribble | first =Dean - | title =Re: [e-lang] "Capability Myths Demolished" => ambient authority revisited - | mailing-list =e-lang - | date =5 December 2002 - | url =http://zesty.ca/zest/out/msg00139.html - | access-date =June 28, 2012 -}} In this definition, * a "name" is any way of referring to an object that does not itself include authorising information, and could potentially be used by any subject; @@ -51,11 +23,3 @@ When ambient authority is requested, permissions are granted or denied based on The term "ambient authority" is used primarily to contrast with [[capability-based security]] (including [[object-capability model]]s), in which executing programs receive permissions as they might receive data, as communicated [[first-class object]] references. This allows them to determine where the permissions came from, and thus avoid the [[Confused deputy problem]]. However, since there are additional requirements for a system to be considered a capability system besides avoiding ambient authority, "non-ambient authority system" is not just a synonym for "capability system". Ambient authority is the dominant form of access control in computer systems today. The ''user'' model of access control as used in Unix and in Windows systems is an ambient authority model because programs execute with the authorities of the ''user'' that started them. This not only means that executing programs are inevitably given more permissions (see [[Principle of least privilege]]) than they need for their task, but that they are unable to determine the source or the number and types of permission that they have.{{cite book |chapter=Capability Computing at LLNL |author=Jed Donnelley |date=May 4, 2005 |chapter-url=https://www.computer-history.info/Page4.dir/pages/LTSS.NLTSS.dir/pages/cap-livermore.html |access-date=2022-12-06 |title=Stories of the Development of Large Scale Scientific Computing at Lawrence Livermore National Laboratory; An Oral and Pictorial History |url=https://www.computer-history.info/ |editor=George A. Michael |editor-link=George Michael (computational physicist)}} A program executing under an ambient authority access control model has little option but to designate permissions and try to exercise them, hoping for the best. This property requires an excess of permissions to be granted to users or roles, in order for programs to execute without error. - -==References== -{{Reflist}} - -{{Object-capability security}} - -{{DEFAULTSORT:Ambient Authority}} -[[Category:Access control]] diff --git a/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt b/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt index 69c9328c4..f998ec779 100644 --- a/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt +++ b/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt @@ -1,10 +1,10 @@ {{Short description|Computer security vulnerability}} -In [[information security]], a '''confused deputy''' is a [[computer program]] that is tricked by another program (with fewer privileges or less rights) into misusing its authority on the system. It is a specific type of [[privilege escalation]].{{Cite journal|last=Wu|first=Jianliang|last2=Cui|first2=Tingting|last3=Ban|first3=Tao|last4=Guo|first4=Shanqing|last5=Cui|first5=Lizhen|date=2015-09-10|title=PaddyFrog: systematically detecting confused deputy vulnerability in Android applications: PaddyFrog: systematically detecting confused deputy vulnerability in Android applications|url=https://onlinelibrary.wiley.com/doi/10.1002/sec.1179|journal=Security and Communication Networks|language=en|volume=8|issue=13|pages=2338–2349|doi=10.1002/sec.1179}} The '''confused deputy problem''' is often cited as an example of why [[capability-based security]] is important. +In [[information security]], a '''confused deputy''' is a [[computer program]] that is tricked by another program (with fewer privileges or less rights) into misusing its authority on the system. It is a specific type of [[privilege escalation]]. The '''confused deputy problem''' is often cited as an example of why [[capability-based security]] is important. -[[Capability-based security|Capability systems]] protect against the confused deputy problem, whereas [[access-control list]]–based systems do not.{{cite web|url=http://waterken.sourceforge.net/aclsdont/|title=ACLs don't|work=sourceforge.net}} +[[Capability-based security|Capability systems]] protect against the confused deputy problem, whereas [[access-control list]]–based systems do not. == Example == -In the original example of a confused deputy,{{cite web|title=The Confused Deputy (or why capabilities might have been invented)|url=http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html|url-status=dead|access-date=2003-12-31|archiveurl=https://web.archive.org/web/20031205034929/http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html|archivedate=2003-12-05}} there was a [[compiler]] program provided on a commercial [[Time-sharing|timesharing]] service. Users could run the compiler and optionally specify a filename where it would write debugging output, and the compiler would be able to write to that file if the user had permission to write there. +In the original example of a confused deputy, there was a [[compiler]] program provided on a commercial [[Time-sharing|timesharing]] service. Users could run the compiler and optionally specify a filename where it would write debugging output, and the compiler would be able to write to that file if the user had permission to write there. The compiler also collected statistics about language feature usage. Those statistics were stored in a file called "(SYSX)STAT", in the directory "SYSX". To make this possible, the compiler program was given permission to write to files in SYSX. @@ -22,16 +22,15 @@ It is not essential to the attack that the billing file be designated by a name * the program's own permission to access the file is used implicitly. == Other examples == -[[File:Don Knotts Barney and the bullet Andy Griffith Show.jpg|thumb|Prototypical confused deputy [[Barney Fife]]]] A [[cross-site request forgery]] (CSRF) is an example of a confused deputy attack that uses the [[web browser]] to perform sensitive actions against a web application. A common form of this attack occurs when a web application uses a cookie to authenticate all requests transmitted by a browser. Using [[JavaScript]], an attacker can force a browser into transmitting authenticated [[HTTP]] requests. The [[Samy (computer worm)|Samy computer worm]] used [[cross-site scripting]] (XSS) to turn the browser's authenticated MySpace session into a confused deputy. Using XSS the worm forced the browser into posting an executable copy of the worm as a MySpace message which was then viewed and executed by friends of the infected user. -[[Clickjacking]] is an attack where the user acts as the confused deputy. In this attack a user thinks they are harmlessly browsing a website (an attacker-controlled website) but they are in fact tricked into performing sensitive actions on another website.{{cite web|url=http://waterken.sourceforge.net/clickjacking/|title=clickjacking: The Confused Deputy rides again!|work=sourceforge.net}} +[[Clickjacking]] is an attack where the user acts as the confused deputy. In this attack a user thinks they are harmlessly browsing a website (an attacker-controlled website) but they are in fact tricked into performing sensitive actions on another website. An [[FTP bounce attack]] can allow an attacker to connect indirectly to [[Transmission Control Protocol|TCP]] [[TCP ports|ports]] to which the attacker's machine has no access, using a remote [[FTP]] server as the confused deputy. -Another example relates to [[personal firewall]] software. It can restrict Internet access for specific applications. Some applications circumvent this by starting a browser with instructions to access a specific URL. The browser has authority to open a network connection, even though the application does not. Firewall software can attempt to address this by prompting the user in cases where one program starts another which then accesses the network. However, the user frequently does not have sufficient information to determine whether such an access is legitimate—false positives are common, and there is a substantial risk that even sophisticated users will become habituated to clicking "OK" to these prompts.Alfred Spiessens: Patterns of Safe Collaboration, PhD thesis. http://www.evoluware.eu/fsp_thesis.pdf Section 8.1.5 +Another example relates to [[personal firewall]] software. It can restrict Internet access for specific applications. Some applications circumvent this by starting a browser with instructions to access a specific URL. The browser has authority to open a network connection, even though the application does not. Firewall software can attempt to address this by prompting the user in cases where one program starts another which then accesses the network. However, the user frequently does not have sufficient information to determine whether such an access is legitimate—false positives are common, and there is a substantial risk that even sophisticated users will become habituated to clicking "OK" to these prompts. Not every program that misuses authority is a confused deputy. Sometimes misuse of authority is simply a result of a program error. The confused deputy problem occurs when the designation of an object is passed from one program to another, and the associated permission changes unintentionally, without any explicit action by either party. It is insidious because neither party did anything explicit to change the authority. @@ -41,27 +40,6 @@ In some systems it is possible to ask the operating system to open a file using * It becomes more difficult to identify the correct permission if the server is in turn the client of another service and wants to pass along access to the file. * It requires the client to trust the server to not abuse the borrowed permissions. Note that intersecting the server and client's permissions does not solve the problem either, because the server may then have to be given very wide permissions (all of the time, rather than those needed for a given request) in order to act for arbitrary clients. -The simplest way to solve the confused deputy problem is to bundle together the designation of an object and the permission to access that object. This is exactly what a [[object-capability model|capability]] is.{{citation needed|reason=The capability model hardly is a silver bullet.|date=April 2023}} +The simplest way to solve the confused deputy problem is to bundle together the designation of an object and the permission to access that object. This is exactly what a [[object-capability model|capability]] is. Using capability security in the compiler example, the client would pass to the server a capability to the output file, such as a [[file descriptor]], rather than the name of the file. Since it lacks a capability to the billing file, it cannot designate that file for output. In the cross-site request forgery example, a URL supplied "cross"-site would include its own authority independent of that of the client of the web browser. - -== See also == - -* [[Setuid]] executables in Unix -* [[Ambient authority]] - -== References == -{{Reflist}} - -== External links == -* Norman Hardy, ''The Confused Deputy: (or why capabilities might have been invented)'', ACM SIGOPS Operating Systems Review, Volume 22, Issue 4 (October 1988). -** [http://portal.acm.org/citation.cfm?id=871709 ACM published document]. -** [http://cap-lore.com/CapTheory/ConfusedDeputy.html Document text on Norm Hardy's website]. -** [https://web.archive.org/web/20031205034929/http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html Document text on University of Pennsylvania's website]. -** [http://citeseer.ist.psu.edu/hardy94confused.html Citeseer cross reference]. -* [http://cap-lore.com/CapTheory/ Capability Theory Notes from several sources (collated by Norm Hardy)]. -* [https://everything2.com/title/confused+deputy Everything2: Confused Deputy] (some introductory level text). - -{{Object-capability security}} - -[[Category:Computer security]] diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 09f8825cf..31cda60cf 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -8,32 +8,52 @@ import { makeCommandStream } from './streams'; import { makeSQLKVStore } from '../kernel/sqlite-kv-store'; import { Ollama } from 'ollama'; -const DEFAULT_MODEL = 'deepseek-r1:1.5b'; +import { MemoryVectorStore } from "langchain/vectorstores/memory"; +import { OllamaEmbeddings } from '@langchain/ollama'; + +const DEFAULT_LLM_MODEL = 'deepseek-r1:1.5b-8k'; +const DEFAULT_EMBED_MODEL = 'mxbai-embed-large-8k'; const vatId = process.env.NODE_VAT_ID as VatId; -const model = process.env.MODEL ?? DEFAULT_MODEL as string; if (vatId) { const logger = makeLogger(`[vat-worker (${vatId})]`); - main().catch(logger.error); + main({ + host: "http://localhost:11434", + models: { + llm: process.env.LLM_MODEL ?? DEFAULT_LLM_MODEL as string, + embedding: process.env.EMBED_MODEL ?? DEFAULT_EMBED_MODEL as string, + }, + }).catch(logger.error); } else { console.log('no vatId set for env variable NODE_VAT_ID'); } +type Args = { + host: string, + models: { + llm: string, + embedding: string, + }, +}; + /** * The main function for the iframe. */ -async function main(): Promise { +async function main({ host, models }: Args): Promise { const commandStream = makeCommandStream(); await commandStream.synchronize(); - const host = "http://localhost:11434"; - // XXX This makes duplicate powers, even for vats that don't need them >:[ // Some method is necessary for designating the appropriate powers when the // kernel is starting the vat. Running software doesn't need full isolation, // only its access within the program; the const ollama = new Ollama({ host }); + const embeddings = new OllamaEmbeddings({ baseUrl: host }); + // const embeddings = new OpenAIEmbeddings(); + const vectorStore = new MemoryVectorStore(embeddings); + + const getVectorStore = () => vectorStore; // eslint-disable-next-line no-void void new VatSupervisor({ @@ -41,8 +61,7 @@ async function main(): Promise { commandStream, makeKVStore: makeSQLKVStore, makePowers: async () => { - await ollama.pull({ model }); - return { ollama }; + return { ollama, getVectorStore }; } }); } diff --git a/vitest.config.ts b/vitest.config.ts index f8fea619c..e7f5940aa 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -74,10 +74,10 @@ export default defineConfig({ lines: 74.05, }, 'packages/kernel/**': { - statements: 48.54, + statements: 48.55, functions: 59.6, - branches: 36.45, - lines: 48.79, + branches: 36.89, + lines: 48.86, }, 'packages/nodejs/**': { statements: 46.75, @@ -112,4 +112,4 @@ export default defineConfig({ }, }, }, -}); +}); \ No newline at end of file diff --git a/yarn.lock b/yarn.lock index 6f26aed12..77a1635c0 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1675,7 +1675,7 @@ __metadata: languageName: node linkType: hard -"@langchain/textsplitters@npm:>=0.0.0 <0.2.0": +"@langchain/textsplitters@npm:>=0.0.0 <0.2.0, @langchain/textsplitters@npm:^0.1.0": version: 0.1.0 resolution: "@langchain/textsplitters@npm:0.1.0" dependencies: @@ -2567,6 +2567,7 @@ __metadata: "@langchain/core": "npm:^0.3.37" "@langchain/ollama": "npm:^0.1.5" "@langchain/openai": "npm:^0.4.2" + "@langchain/textsplitters": "npm:^0.1.0" "@metamask/auto-changelog": "npm:^4.0.0" "@metamask/eslint-config": "npm:^14.0.0" "@metamask/eslint-config-nodejs": "npm:^14.0.0" From ad796080bb3d57269b20255e3c66967031ff62cb Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Thu, 6 Feb 2025 12:33:11 -0600 Subject: [PATCH 34/55] Alice & Bob: draft --- .../nodejs/src/demo/rag/subclusterConfig.ts | 7 +++- packages/nodejs/src/demo/rag/vats/README.md | 0 packages/nodejs/src/demo/rag/vats/boot.js | 0 packages/nodejs/src/demo/rag/vats/ollama.js | 40 +++++++++++-------- 4 files changed, 28 insertions(+), 19 deletions(-) create mode 100644 packages/nodejs/src/demo/rag/vats/README.md create mode 100644 packages/nodejs/src/demo/rag/vats/boot.js diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts index 4e099e1ca..5a7b4684f 100644 --- a/packages/nodejs/src/demo/rag/subclusterConfig.ts +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -33,10 +33,12 @@ const getWikiContent = async (path: string) => { } export const makeConfig = async ( + users: string, + bootstrap: string, model: Model, verbose: boolean = false, ): Promise => ({ - bootstrap: 'user', + bootstrap, vats: { // The LLM vat with the special ollama vat power. ollama: { @@ -51,9 +53,10 @@ export const makeConfig = async ( }, }, // The bootstrap vat representing a user action. - user: { + [name]: { bundleSpec: makeBundleSpec('user'), parameters: { + name, prompt: [ 'Describe the "confused deputy problem".', 'Then, define "object capability model" (OCAP).', diff --git a/packages/nodejs/src/demo/rag/vats/README.md b/packages/nodejs/src/demo/rag/vats/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/packages/nodejs/src/demo/rag/vats/boot.js b/packages/nodejs/src/demo/rag/vats/boot.js new file mode 100644 index 000000000..e69de29bb diff --git a/packages/nodejs/src/demo/rag/vats/ollama.js b/packages/nodejs/src/demo/rag/vats/ollama.js index fdf8754d4..cba9d3de3 100644 --- a/packages/nodejs/src/demo/rag/vats/ollama.js +++ b/packages/nodejs/src/demo/rag/vats/ollama.js @@ -41,15 +41,29 @@ export function buildRootObject(vatPowers, parameters, _baggage) { thisWiki = wiki; }, async chat(prompt) { - if (verbose) { - console.log('chat'); - console.time('llm'); + const { log, time, timeEnd } = verbose + ? { ...console } + : { + log: () => {}, + time: () => {}, + timeEnd: () => {}, + }; + + const bigLog = (title, message) => { + const banner = title.map(() => '-').join(''); + log(`\n${banner}`); + log(title); + log(message); + log(`${banner}\n`); } + + time('llm'); + const docs = thisWiki ? await E(thisWiki).retrieve(prompt) : []; - console.log('RETRIEVED DOCS', docs); + log('RETRIEVED DOCS', docs); const messages = [ { @@ -62,10 +76,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { { role: 'user', content: prompt }, ]; - console.log('\n--------'); - console.log('MESSAGES') - console.log(JSON.stringify(messages, null, 2)); - console.log('--------\n'); + bigLog('MESSAGES', JSON.stringify(messages, null, 2)); const response = await ollama.chat({ model: `${model}-8k`, @@ -73,15 +84,10 @@ export function buildRootObject(vatPowers, parameters, _baggage) { }); const { thought, speech } = parseResponse(response); - console.log('\n--------'); - console.log('THOUGHTS'); - console.log(JSON.stringify(thought.split('\n\n'), null, 2)); - console.log('--------\n'); - - if (verbose) { - console.timeEnd('llm'); - console.debug('Thought:', thought); - } + bigLog('THOUGHTS', JSON.stringify(thought.split('\n\n'), null, 2)); + + timeEnd('llm'); + return speech; }, }); From 2ae278baae8ee8d2f088ce7f0dce43c2dfb9fc29 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 11 Feb 2025 14:14:49 -0600 Subject: [PATCH 35/55] trim kernel reports --- packages/kernel/src/Kernel.ts | 8 ++++++-- packages/kernel/src/VatHandle.ts | 18 +++++++++++------- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 149cde29b..1560b6f8a 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -67,6 +67,9 @@ type MessageRoute = { target: KRef; } | null; +const clip = (content: string, length = 10) => + `${content.substring(0, length)}${content.length > length ? '...' : ''}`; + export class Kernel { /** Command channel from the controlling console/browser extension/test driver */ readonly #commandStream: DuplexStream; @@ -476,6 +479,7 @@ export class Kernel { */ async #deliver(item: RunQueueItem): Promise { const { log } = console; + const glimpse = (obj: unknown) => clip(JSON.stringify(obj)); switch (item.type) { case 'send': { const route = this.#routeMessage(item); @@ -483,7 +487,7 @@ export class Kernel { const { vatId, target } = route; const { message } = item; log( - `@@@@ deliver ${vatId} send ${target}<-${JSON.stringify(message)}`, + `@@@@ deliver ${vatId} send ${target}<-${glimpse(message)}`, ); if (vatId) { const vat = this.#getVat(vatId); @@ -503,7 +507,7 @@ export class Kernel { } else { this.#storage.enqueuePromiseMessage(target, message); } - log(`@@@@ done ${vatId} send ${target}<-${JSON.stringify(message)}`); + log(`@@@@ done ${vatId} send ${target}<-${glimpse(message)}`); } break; } diff --git a/packages/kernel/src/VatHandle.ts b/packages/kernel/src/VatHandle.ts index 6e8a02694..3ddf52c1f 100644 --- a/packages/kernel/src/VatHandle.ts +++ b/packages/kernel/src/VatHandle.ts @@ -39,6 +39,9 @@ type VatConstructorProps = { logger?: Logger | undefined; }; +const clip = (content: string, length = 10) => + `${content.substring(0, length)}${content.length > length ? '...' : ''}`; + export class VatHandle { /** The ID of the vat this is the VatHandle for */ readonly vatId: VatId; @@ -268,11 +271,12 @@ export class VatHandle { const [op] = kso; const { vatId } = this; const { log } = console; + const glimpse = (obj: unknown) => clip(JSON.stringify(obj)); switch (op) { case 'send': { // [KRef, Message]; const [, target, message] = kso; - log(`@@@@ ${vatId} syscall send ${target}<-${JSON.stringify(message)}`); + log(`@@@@ ${vatId} syscall send ${target}<-${glimpse(message)}`); this.#handleSyscallSend(target, message); break; } @@ -286,38 +290,38 @@ export class VatHandle { case 'resolve': { // [VatOneResolution[]]; const [, resolutions] = kso; - log(`@@@@ ${vatId} syscall resolve ${JSON.stringify(resolutions)}`); + log(`@@@@ ${vatId} syscall resolve ${glimpse(resolutions)}`); this.#handleSyscallResolve(resolutions as VatOneResolution[]); break; } case 'exit': { // [boolean, SwingSetCapData]; const [, fail, info] = kso; - log(`@@@@ ${vatId} syscall exit fail=${fail} ${JSON.stringify(info)}`); + log(`@@@@ ${vatId} syscall exit fail=${fail} ${glimpse(info)}`); break; } case 'dropImports': { // [KRef[]]; const [, refs] = kso; - log(`@@@@ ${vatId} syscall dropImports ${JSON.stringify(refs)}`); + log(`@@@@ ${vatId} syscall dropImports ${glimpse(refs)}`); break; } case 'retireImports': { // [KRef[]]; const [, refs] = kso; - log(`@@@@ ${vatId} syscall retireImports ${JSON.stringify(refs)}`); + log(`@@@@ ${vatId} syscall retireImports ${glimpse(refs)}`); break; } case 'retireExports': { // [KRef[]]; const [, refs] = kso; - log(`@@@@ ${vatId} syscall retireExports ${JSON.stringify(refs)}`); + log(`@@@@ ${vatId} syscall retireExports ${glimpse(refs)}`); break; } case 'abandonExports': { // [KRef[]]; const [, refs] = kso; - log(`@@@@ ${vatId} syscall abandonExports ${JSON.stringify(refs)}`); + log(`@@@@ ${vatId} syscall abandonExports ${glimpse(refs)}`); break; } case 'callNow': From df9983d4ed85002d39031a1c9570a4f4d2faa246 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Feb 2025 12:10:07 -0600 Subject: [PATCH 36/55] endow Alice, Bob & Eve w/ trust --- packages/nodejs/package.json | 3 +- packages/nodejs/scripts/call-ollama.js | 64 ++-- .../nodejs/src/bundle-example/doBundle.mjs | 13 +- packages/nodejs/src/bundle-example/lib.mjs | 6 +- packages/nodejs/src/bundle-example/vat.js | 1 + .../src/demo/rag/models/pull-and-make.ts | 44 +-- packages/nodejs/src/demo/rag/run.ts | 78 ++++- .../nodejs/src/demo/rag/subclusterConfig.ts | 102 +++--- packages/nodejs/src/demo/rag/vats/boot.bundle | 1 + packages/nodejs/src/demo/rag/vats/boot.js | 80 +++++ packages/nodejs/src/demo/rag/vats/llm.bundle | 1 + packages/nodejs/src/demo/rag/vats/llm.js | 175 ++++++++++ .../nodejs/src/demo/rag/vats/ollama.bundle | 1 - packages/nodejs/src/demo/rag/vats/ollama.js | 94 ------ packages/nodejs/src/demo/rag/vats/user.bundle | 2 +- packages/nodejs/src/demo/rag/vats/user.js | 317 ++++++++++++++++-- .../src/demo/rag/vats/vectorStore.bundle | 1 + .../nodejs/src/demo/rag/vats/vectorStore.js | 67 ++++ packages/nodejs/src/demo/rag/vats/wiki.bundle | 1 - packages/nodejs/src/demo/rag/vats/wiki.js | 36 -- .../src/demo/rag/wiki/consensys-ipo.txt | 18 + packages/nodejs/src/kernel/sqlite-kv-store.ts | 5 +- packages/nodejs/src/vat/vat-worker.ts | 32 +- packages/nodejs/tsconfig.json | 3 +- vitest.config.ts | 2 +- yarn.lock | 5 +- 26 files changed, 847 insertions(+), 305 deletions(-) create mode 100644 packages/nodejs/src/demo/rag/vats/boot.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/llm.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/llm.js delete mode 100644 packages/nodejs/src/demo/rag/vats/ollama.bundle delete mode 100644 packages/nodejs/src/demo/rag/vats/ollama.js create mode 100644 packages/nodejs/src/demo/rag/vats/vectorStore.bundle create mode 100644 packages/nodejs/src/demo/rag/vats/vectorStore.js delete mode 100644 packages/nodejs/src/demo/rag/vats/wiki.bundle delete mode 100644 packages/nodejs/src/demo/rag/vats/wiki.js create mode 100644 packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index a5ec4305f..559e9627c 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -81,9 +81,10 @@ "node": "^20 || >=22" }, "dependencies": { - "@endo/eventual-send": "^1.3.0", + "@endo/eventual-send": "^1.2.6", "@endo/marshal": "^1.6.2", "@endo/promise-kit": "^1.1.6", + "@endo/stream": "^1.2.6", "@huggingface/transformers": "^3.3.2", "@langchain/core": "^0.3.37", "@langchain/ollama": "^0.1.5", diff --git a/packages/nodejs/scripts/call-ollama.js b/packages/nodejs/scripts/call-ollama.js index 206520f47..cf9ade805 100644 --- a/packages/nodejs/scripts/call-ollama.js +++ b/packages/nodejs/scripts/call-ollama.js @@ -1,6 +1,10 @@ import { readFile } from 'fs/promises'; import ollama from 'ollama'; +/** + * + * @param response + */ async function streamResponse(response) { const thinkEndToken = ''; const thinkLabel = 'OLLAMA Thought'; @@ -9,15 +13,12 @@ async function streamResponse(response) { let thinkingDotsIndex = 0; let thinking = true; let accumulatedContent = ''; - const thinkingInterval = setInterval( - () => { - process.stdout.clearLine(); - process.stdout.write(`OLLAMA Thinking${thinkingDots[thinkingDotsIndex]}\r`); - thinkingDotsIndex += 1; - thinkingDotsIndex %= thinkingDots.length; - }, - dotInterval, - ); + const thinkingInterval = setInterval(() => { + process.stdout.clearLine(); + process.stdout.write(`OLLAMA Thinking${thinkingDots[thinkingDotsIndex]}\r`); + thinkingDotsIndex += 1; + thinkingDotsIndex %= thinkingDots.length; + }, dotInterval); console.time(thinkLabel); for await (const part of response) { accumulatedContent += part.message.content; @@ -39,11 +40,11 @@ async function streamResponse(response) { const getFileContent = async (path) => { const resolvedPath = new URL(path, import.meta.url).pathname; return (await readFile(resolvedPath)).toString(); -} +}; /** * The main function for the script. - * + * * @param {*} param0 - An arguments bag. * @param { string } param0.model - The model to pull and use. * @param { string } param0.prompt - The prompt to give the model. @@ -56,27 +57,36 @@ async function main({ model, prompt }) { console.log('OLLAMA', 'pull'); await ollama.pull({ model }); - + console.log('USER:', prompt); const response = await ollama.chat({ model, // Specify the model you want to use messages: [ - { role: 'admin', content: [ - `You are an instance of LLM model ${model}.`, - `Respond to user requests ${'respectfully'} and ${'informatively'}.`, - ].join(' ')}, - { role: 'admin', content: [ - 'The following is the raw content of the wikipedia page titled "ambient authority".', - await getFileContent('./ambient-authority.txt'), - ].join('\n\n')}, - { role: 'admin', content: [ - 'The following is the raw content of the wikipedia page titled "confused deputy problem".', - await getFileContent('./confused-deputy-problem.txt'), - ].join('\n\n')}, - { role: 'user', content: prompt } + { + role: 'admin', + content: [ + `You are an instance of LLM model ${model}.`, + `Respond to user requests ${'respectfully'} and ${'informatively'}.`, + ].join(' '), + }, + { + role: 'admin', + content: [ + 'The following is the raw content of the wikipedia page titled "ambient authority".', + await getFileContent('./ambient-authority.txt'), + ].join('\n\n'), + }, + { + role: 'admin', + content: [ + 'The following is the raw content of the wikipedia page titled "confused deputy problem".', + await getFileContent('./confused-deputy-problem.txt'), + ].join('\n\n'), + }, + { role: 'user', content: prompt }, ], // The message to send - stream: true // Enable streaming + stream: true, // Enable streaming }); await streamResponse(response).catch(console.error); @@ -85,6 +95,6 @@ async function main({ model, prompt }) { const model = 'deepseek-r1:1.5b'; -const [,, prompt] = process.argv; +const [, , prompt] = process.argv; main({ model, prompt }).catch(console.error); diff --git a/packages/nodejs/src/bundle-example/doBundle.mjs b/packages/nodejs/src/bundle-example/doBundle.mjs index 9ac104d9d..675af72dd 100644 --- a/packages/nodejs/src/bundle-example/doBundle.mjs +++ b/packages/nodejs/src/bundle-example/doBundle.mjs @@ -1,13 +1,16 @@ import '@ocap/shims/endoify'; import bundleSource from '@endo/bundle-source'; -import { resolve } from './lib.mjs'; import { writeFile } from 'fs/promises'; -main( - resolve('vat.js'), - resolve('vat.bundle'), -).catch(console.error); +import { resolve } from './lib.mjs'; + +main(resolve('vat.js'), resolve('vat.bundle')).catch(console.error); +/** + * + * @param source + * @param target + */ async function main(source, target) { console.log('bundleSource', bundleSource); const bundle = await bundleSource(source); diff --git a/packages/nodejs/src/bundle-example/lib.mjs b/packages/nodejs/src/bundle-example/lib.mjs index 4029f3599..18f17a3ab 100644 --- a/packages/nodejs/src/bundle-example/lib.mjs +++ b/packages/nodejs/src/bundle-example/lib.mjs @@ -3,17 +3,17 @@ const url = await import('url'); /** * Resolve a path given relative to this file. - * + * * @param {string} relativePath - The path to load, relative to this file. * @returns An absolute filepath. */ export function resolve(relativePath) { return url.fileURLToPath(new URL(relativePath, import.meta.url)); -}; +} /** * Load the content from the file at the given filepath. - * + * * @param {string} relativePath - The path to load, relative to this file. * @returns The data stored in filepath. */ diff --git a/packages/nodejs/src/bundle-example/vat.js b/packages/nodejs/src/bundle-example/vat.js index bcec0c479..c18708b02 100644 --- a/packages/nodejs/src/bundle-example/vat.js +++ b/packages/nodejs/src/bundle-example/vat.js @@ -1,4 +1,5 @@ import { Far } from '@endo/marshal'; + import { getContent } from './lib.mjs'; /** diff --git a/packages/nodejs/src/demo/rag/models/pull-and-make.ts b/packages/nodejs/src/demo/rag/models/pull-and-make.ts index 4985e1a2c..aec5babc0 100644 --- a/packages/nodejs/src/demo/rag/models/pull-and-make.ts +++ b/packages/nodejs/src/demo/rag/models/pull-and-make.ts @@ -1,36 +1,38 @@ import { Ollama } from 'ollama'; -const ollama = new Ollama({ host: "http://localhost:11434" }); +const ollama = new Ollama({ host: 'http://localhost:11434' }); const affix8k = '8k'; const models = { llm: ['1.5b', '7b'].map((size) => `deepseek-r1:${size}`), - embeddings: ['mxbai-embed-large'] + embeddings: ['mxbai-embed-large'], }; -const make8kModel = (model: string) => ollama.create({ - model: `${model}-${affix8k}`, - from: model, - parameters: { - num_ctx: 8096, - }, -}); +const make8kModel = async (model: string) => + ollama.create({ + model: `${model}-${affix8k}`, + from: model, + parameters: { + num_ctx: 8096, + }, + }); -const pull = async (modelsToPull: string[] = [ - ...models.llm, - ...models.embeddings, -]) => { - await Promise.all(modelsToPull.map((model) => ollama.pull({ model }))); -} +const pull = async ( + modelsToPull: string[] = [...models.llm, ...models.embeddings], +) => { + await Promise.all(modelsToPull.map(async (model) => ollama.pull({ model }))); +}; -const make8kLLMs = async (modelsToMake: string[] = [ - ...models.llm, - ...models.embeddings, -]) => { - await Promise.all(modelsToMake.map((model) => make8kModel(model))); -} +const make8kLLMs = async ( + modelsToMake: string[] = [...models.llm, ...models.embeddings], +) => { + await Promise.all(modelsToMake.map(async (model) => make8kModel(model))); +}; +/** + * + */ export default async function main() { console.log('pulling models', models); await pull(); diff --git a/packages/nodejs/src/demo/rag/run.ts b/packages/nodejs/src/demo/rag/run.ts index c0ecdbcef..f3c4d830e 100644 --- a/packages/nodejs/src/demo/rag/run.ts +++ b/packages/nodejs/src/demo/rag/run.ts @@ -1,14 +1,11 @@ import '@ocap/shims/endoify'; import { Kernel } from '@ocap/kernel'; -import { - MessageChannel as NodeMessageChannel, -} from 'node:worker_threads'; +import type { ClusterConfig } from '@ocap/kernel'; +import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; +import { makeUserConfig } from './subclusterConfig.js'; import { makeKernel } from '../../kernel/make-kernel.js'; -import { makeConfig } from './subclusterConfig.js'; - -import pullAndMakeModels from './models/pull-and-make.js'; const ollamaOnline = async () => { const response = await (await fetch('http://localhost:11434')).text(); @@ -16,20 +13,79 @@ const ollamaOnline = async () => { if (response !== expectation) { throw new Error('Ollama not running', { cause: response }); } -} +}; -main().catch(console.error); +main({ verbose: false }).catch(console.error); /** * The main function for the demo. + * + * @param options0 + * @param options0.verbose */ -async function main() { +async function main({ verbose }: { verbose: boolean }) { await ollamaOnline(); - // await pullAndMakeModels(); // We don't talk to the Kernel via a console (yet) const kernelPort = new NodeMessageChannel().port1; const kernel: Kernel = await makeKernel(kernelPort); - const subclusterConfig = await makeConfig('deepseek-r1:1.5b'); + const aliceConfig = await makeUserConfig('alice', { + // Alice smol brain + model: 'deepseek-r1:1.5b', + // Alice no know thing + docs: [], + trust: { + // Alice trusts Bob thoroughly + bob: 1, + // Alice does not trust Eve + eve: 0, + }, + verbose, + }); + const bobConfig = await makeUserConfig('bob', { + // Bob big brain + model: 'deepseek-r1:7b-8k', + // Bob know much + docs: [ + { path: 'ambient-authority.txt', secrecy: 0 }, + { path: 'confused-deputy-problem.txt', secrecy: 0 }, + { path: 'consensys-ipo.txt', secrecy: 0.6 }, + ], + trust: { + // Bob trusts Alice well + alice: 0.7, + // Bob does not trust Eve + eve: 0, + }, + verbose, + }); + const eveConfig = await makeUserConfig('eve', { + // Eve big brain + model: 'deepseek-r1:7b-8k', + // Eve no know thing + docs: [], + trust: { + // Eve is suspicious of Alice + alice: 0.2, + // Eve trusts Bob very well + bob: 0.9, + }, + verbose, + }); + const subclusterConfig: ClusterConfig = { + bootstrap: 'boot', + vats: { + boot: { + bundleSpec: 'http://localhost:3000/boot.bundle', + parameters: { + users: ['alice', 'bob', 'eve'], + verbose, + }, + }, + ...aliceConfig, + ...bobConfig, + ...eveConfig, + }, + }; console.log('clusterConfig', JSON.stringify(subclusterConfig)); await kernel.launchSubcluster(subclusterConfig); } diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts index 5a7b4684f..d536859c4 100644 --- a/packages/nodejs/src/demo/rag/subclusterConfig.ts +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -1,73 +1,73 @@ - -import { TextLoader } from "langchain/document_loaders/fs/text"; -import type { ClusterConfig } from "@ocap/kernel"; -import { readFile } from "fs/promises"; -import { join } from "path"; -import type { Document } from '@langchain/core/documents'; -import type { Json } from "@metamask/utils"; -import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters"; +import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters'; +import type { VatConfig } from '@ocap/kernel'; +import { TextLoader } from 'langchain/document_loaders/fs/text'; +import { join } from 'path'; type ModelSize = '1.5b' | '7b' | '8b' | '14b' | '32b' | '70b' | '671b'; -type Model = `deepseek-r1:${ModelSize}`; +type Model = `deepseek-r1:${ModelSize}${string}`; const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; -// XXX Todo: RAG in a separate vat, with introduction at bootstrap time. -const getWikiContent = async (path: string) => { - const resolvedPath = new URL(join('wiki', path), import.meta.url).pathname.replace(/\/dist\//, '/src/'); +const getWikiContent = async ({ + path, + secrecy, +}: { + path: string; + secrecy: number; +}) => { + const resolvedPath = new URL( + join('wiki', path), + import.meta.url, + ).pathname.replace(/\/dist\//, '/src/'); const loader = new TextLoader(resolvedPath); const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 384, chunkOverlap: 64, }); const splitDocs = await splitter.splitDocuments(await loader.load()); - console.log('\n----------'); - console.log('SPLIT DOCS'); - console.log('path:', path); - console.log(JSON.stringify(splitDocs, null, 2)); - console.log('----------\n'); return splitDocs.map((document) => ({ pageContent: document.pageContent, - metadata: { source: path }, + metadata: { secrecy, source: path }, })); -} +}; -export const makeConfig = async ( - users: string, - bootstrap: string, - model: Model, - verbose: boolean = false, -): Promise => ({ - bootstrap, - vats: { - // The LLM vat with the special ollama vat power. - ollama: { - bundleSpec: makeBundleSpec('ollama'), - parameters: { model, verbose }, - }, - // A mock wikipedia API which returns the content of a few wikipedia pages. - wiki: { - bundleSpec: makeBundleSpec('wiki'), - parameters: { - model: 'mxbai-embed-large' - }, - }, - // The bootstrap vat representing a user action. +type UserConfig = { + model: Model; + docs: { path: string; secrecy: number }[]; + trust: Record; + verbose?: boolean; +}; + +export const makeUserConfig = async ( + name: string, + config: UserConfig, +): Promise> => { + const { model, docs, trust } = config; + const verbose = config.verbose ?? false; + return { + // The vat representing this user agent. [name]: { bundleSpec: makeBundleSpec('user'), parameters: { name, - prompt: [ - 'Describe the "confused deputy problem".', - 'Then, define "object capability model" (OCAP).', - 'Finally, explain how OCAP solves the confused deputy problem.', - ].join(' '), verbose, - docs: [ - ...await getWikiContent('ambient-authority.txt'), - ...await getWikiContent('confused-deputy-problem.txt'), - ], + docs: (await Promise.all(docs.map(getWikiContent))).flat(), + trust, + }, + }, + + // The LLM vat with the special ollama vat power. + [`${name}.llm`]: { + bundleSpec: makeBundleSpec('llm'), + parameters: { model, verbose }, + }, + // A mock wikipedia API which returns the content of a few wikipedia pages. + [`${name}.vectorStore`]: { + bundleSpec: makeBundleSpec('vectorStore'), + parameters: { + model: 'mxbai-embed-large', + verbose, }, }, - }, -}); + }; +}; diff --git a/packages/nodejs/src/demo/rag/vats/boot.bundle b/packages/nodejs/src/demo/rag/vats/boot.bundle new file mode 100644 index 000000000..0200f4779 --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/boot.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"e333c658b6e98a07d921e0057d546dc848e2d7ac5ed6fb4fb70ead53c216805ed2eb1fa021e1b3c82c5b3952d8f5f38796dfe71f6a6db202c23c06b893be49aa"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/boot.js b/packages/nodejs/src/demo/rag/vats/boot.js index e69de29bb..bafc6c963 100644 --- a/packages/nodejs/src/demo/rag/vats/boot.js +++ b/packages/nodejs/src/demo/rag/vats/boot.js @@ -0,0 +1,80 @@ +import { E } from '@endo/eventual-send'; +import { Far } from '@endo/marshal'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(_vatPowers, parameters, _baggage) { + const { verbose, users } = parameters; + + const logger = { + log: console.log, + debug: verbose ? console.debug : () => {}, + error: console.error, + }; + + const makeInitUser = (vats) => async (user) => { + logger.debug('boot.initUser:user', user); + const response = await E(vats[user]).init( + vats[`${user}.llm`], + vats[`${user}.vectorStore`], + ); + logger.debug('boot.initUser:response', response); + }; + + const displayWithBanner = (title, content) => { + const banner = '---'; + logger.log( + ['', banner, `${title.toUpperCase()}: ${content}`, banner, ''].join('\n'), + ); + }; + + const showUserMessage = (sender, receiver, content) => { + displayWithBanner(`${sender}->${receiver}`, content); + }; + + return Far('root', { + async bootstrap(vats) { + displayWithBanner('demo', 'Bootstrapping'); + + console.time('bootstrap'); + await Promise.all(users.map(makeInitUser(vats))); + console.timeEnd('bootstrap'); + + displayWithBanner('demo', 'Initialized'); + + const interactWithBob = async (user) => { + let whatUserSaid = 'What is the "confused deputy problem"?'; + + showUserMessage(user, 'bob', whatUserSaid); + + console.time(`bob:${user}`); + let whatBobSaid = await E(vats.bob).message(user, whatUserSaid); + await Promise.resolve(); + console.timeEnd(`bob:${user}`); + + showUserMessage('bob', user, whatBobSaid); + + whatUserSaid = 'When does Consensys IPO?'; + + showUserMessage(user, 'bob', whatUserSaid); + + console.time(`bob:${user}`); + whatBobSaid = await E(vats.bob).message(user, whatUserSaid); + await Promise.resolve(); + console.timeEnd(`bob:${user}`); + + showUserMessage('bob', user, whatBobSaid); + }; + + await Promise.all([interactWithBob('alice'), interactWithBob('eve')]); + + displayWithBanner('demo', 'Complete'); + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/vats/llm.bundle b/packages/nodejs/src/demo/rag/vats/llm.bundle new file mode 100644 index 000000000..5d7620a27 --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/llm.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"8f06d781f47e22c2e63bee3dfa077cf2e25fc78608b2447212604cff59de38428554061b6a598fd5d48a75803dcd3bc0ccfdd83b22d9fef6b6372f720c94cfd8"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/llm.js b/packages/nodejs/src/demo/rag/vats/llm.js new file mode 100644 index 000000000..1c0cf4727 --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/llm.js @@ -0,0 +1,175 @@ +import { Far } from '@endo/marshal'; +import { makePipe } from '@endo/stream'; + +// The default LLM model to use. +const DEFAULT_MODEL = 'deepseek-r1:7b'; + +const [thinkStart, thinkEnd] = ['', '']; + +const parseResponse = (response) => { + const [thought, speech] = response.message.content + .substring(thinkStart.length) + .split(thinkEnd) + .map((content) => content.trim()); + return { thought, speech }; +}; + +/** + * Split deepseek generated output into thought and speech async generators. + * + * Assumes that the string represent the beginning and end of thought are + * always* generated as complete tokens, and *never* partially as strings. + * + * @param {*} response - An async generator yielding a deepseek token stream. + * @returns An object with async generator properties 'thought' and 'speech'. + */ +const parseResponseStream = (response) => { + const [thought, thoughtWriter] = makePipe(); + const [speech, speechWriter] = makePipe(); + + const writeToThought = (content) => thoughtWriter.next(content); + const writeToSpeech = (content) => speechWriter.next(content); + + const producer = async () => { + const [INITIALIZING, THINKING, SPEAKING] = ['INIT', 'THINK', 'SPEAK']; + let state = INITIALIZING; + let accumulatedContent = ''; + for await (const part of response) { + accumulatedContent += part.message.content; + switch (state) { + case INITIALIZING: + if (accumulatedContent.startsWith(thinkStart)) { + accumulatedContent = accumulatedContent.substring( + thinkStart.length, + ); + state = THINKING; + writeToThought(accumulatedContent); + } + break; + case THINKING: + if (accumulatedContent.includes(thinkEnd)) { + const [head, tail] = accumulatedContent.split(thinkEnd); + writeToThought(head); + state = SPEAKING; + writeToSpeech(tail); + } + break; + case SPEAKING: + writeToSpeech(part.message.content); + break; + default: + throw new Error( + 'Reached unexpected state during deepseek stream parse', + { cause: { state, accumulatedContent } }, + ); + } + } + }; + + producer().catch((reason) => { + thoughtWriter.throw(reason); + speechWriter.throw(reason); + }); + + return { thought, speech }; +}; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} vatPowers - Special powers granted to this vat. + * @param {() => Promise} vatPowers.ollama - An Ollama instance ready for use. + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(vatPowers, parameters, _baggage) { + const model = parameters?.model ?? DEFAULT_MODEL; + const { verbose } = parameters; + const { ollama } = vatPowers; + + const logger = { + log: console.log, + debug: verbose ? console.debug : () => {}, + error: console.error, + }; + + const logThoughts = async (thoughts, stream, log) => { + if (stream) { + for await (const thought of thoughts) { + log(thought); + } + } else { + log(await thoughts); + } + }; + + const hasCtxSuffix = model.match(/-[0-9]+((\.[0-9]+))?k$/u) !== null; + const mapCtxSuffix = (suffix) => { + switch (suffix) { + case '8k': + return 8096; + default: + throw new Error(`Unrecognized context window suffix ${suffix}.`); + } + }; + return Far('root', { + async init() { + const toReturn = []; + const modelSplit = model.split('-'); + + const toPull = hasCtxSuffix + ? modelSplit.slice(0, modelSplit.length - 1).join('-') + : model; + + logger.debug( + 'pulling:', + JSON.stringify({ + modelSplit, + toPull, + hasCtxSuffix, + }), + ); + toReturn.push(await ollama.pull({ model: toPull })); + + if (hasCtxSuffix) { + toReturn.push( + await ollama.create({ + model, + from: toPull, + parameters: { + num_ctx: mapCtxSuffix(modelSplit.at(modelSplit.length - 1)), + }, + }), + ); + } + + return toReturn; + }, + async generate(prompt, stream, raw = false) { + const result = await ollama.generate({ + model, + prompt, + stream, + raw, + }); + return Far('response', { response: result.response }); + }, + async chat(messages, stream) { + logger.debug('llm.chat:messages', messages); + const response = ollama.chat({ model, messages, stream }); + const { thought, speech } = stream + ? parseResponseStream(response) + : parseResponse(await response); + + logThoughts(thought, stream, logger.debug).catch((reason) => { + logger.error(thought); + speech.throw(reason); + }); + + const toReturn = stream ? Far('speech', speech) : speech; + + return toReturn; + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/vats/ollama.bundle b/packages/nodejs/src/demo/rag/vats/ollama.bundle deleted file mode 100644 index 8353d42e8..000000000 --- a/packages/nodejs/src/demo/rag/vats/ollama.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"ee2bc9349fce69083be4927550ffd955d19803a05183e9c7b911f8bdb4d6ab4cfe0ef5d46741b4f8daf57c526891eb754c7a743def387ee6dff124f74896e505"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/ollama.js b/packages/nodejs/src/demo/rag/vats/ollama.js deleted file mode 100644 index cba9d3de3..000000000 --- a/packages/nodejs/src/demo/rag/vats/ollama.js +++ /dev/null @@ -1,94 +0,0 @@ -import { E } from '@endo/eventual-send'; -import { Far } from '@endo/marshal'; - -// The default LLM model to use. -const DEFAULT_MODEL = 'deepseek-r1:7b'; - -const parseResponse = (response) => { - const thinkTokens = ['', '']; - const trimmed = response.message.content.startsWith('') - ? response.message.content.substring(thinkTokens[0].length) - : response.message.content; - const [thought, speech] = trimmed.split(thinkTokens[1]); - return { - thought: thought.trim(), - speech: speech.trim(), - }; -}; - -const clip = (content, length = 10) => - `${content.substring(0, length)}${content.length > length ? '...' : ''}`; - -/** - * Build function for the LLM test vat. - * - * @param {unknown} vatPowers - Special powers granted to this vat. - * @param {() => Promise} vatPowers.ollama - An Ollama instance ready for use. - * @param {unknown} parameters - Initialization parameters from the vat's config object. - * @param {unknown} _baggage - Root of vat's persistent state (not used here). - * @returns {unknown} The root object for the new vat. - */ -export function buildRootObject(vatPowers, parameters, _baggage) { - const model = parameters?.model ?? DEFAULT_MODEL; - const { verbose } = parameters; - const { ollama } = vatPowers; - let thisWiki; - - console.debug(`buildRootObject "${JSON.stringify({ model, ollama })}"`); - - return Far('root', { - setWiki(wiki) { - thisWiki = wiki; - }, - async chat(prompt) { - const { log, time, timeEnd } = verbose - ? { ...console } - : { - log: () => {}, - time: () => {}, - timeEnd: () => {}, - }; - - const bigLog = (title, message) => { - const banner = title.map(() => '-').join(''); - log(`\n${banner}`); - log(title); - log(message); - log(`${banner}\n`); - } - - time('llm'); - - const docs = thisWiki - ? await E(thisWiki).retrieve(prompt) - : []; - - log('RETRIEVED DOCS', docs); - - const messages = [ - { - role: 'user', - content: [ - 'You may find some or all of the following information helpful when responding to my request.', - ...docs.map(({ pageContent }) => pageContent) - ].join('\n\n') - }, - { role: 'user', content: prompt }, - ]; - - bigLog('MESSAGES', JSON.stringify(messages, null, 2)); - - const response = await ollama.chat({ - model: `${model}-8k`, - messages, - }); - const { thought, speech } = parseResponse(response); - - bigLog('THOUGHTS', JSON.stringify(thought.split('\n\n'), null, 2)); - - timeEnd('llm'); - - return speech; - }, - }); -} diff --git a/packages/nodejs/src/demo/rag/vats/user.bundle b/packages/nodejs/src/demo/rag/vats/user.bundle index 34f4976e9..fb42ef07d 100644 --- a/packages/nodejs/src/demo/rag/vats/user.bundle +++ b/packages/nodejs/src/demo/rag/vats/user.bundle @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"3c03f7da98cef4668100d78ab7342043af3e9f6a8a18fe8e28859eb77984b5c292f7e2c49dde9dc2aa4f933c4af6e04019a92ae033c9751fdf48df2cbf72390c"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"85a6136531ca880ac1d3e2e5477bb7f68f59d3b5ec8be896ee0fad70e03798be9a21e54c217c6d1ae625541cbf892bee75e8f46aea320459642daa1c8e42b378"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js index d258541b1..5179bf142 100644 --- a/packages/nodejs/src/demo/rag/vats/user.js +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -9,40 +9,297 @@ import { Far } from '@endo/marshal'; * @param {unknown} _baggage - Root of vat's persistent state (not used here). * @returns {unknown} The root object for the new vat. */ -export function buildRootObject(vatPowers, parameters, _baggage) { - const prompt = parameters?.prompt ?? `Say hello.`; - const { verbose, docs } = parameters; +export function buildRootObject(_vatPowers, parameters, _baggage) { + const { name, verbose, trust, docs } = parameters; + const stream = false; - return Far('root', { - async bootstrap(vats) { - if (verbose) { - console.log('Bootstrap') + const logger = { + log: console.log, + debug: verbose ? console.debug : () => {}, + error: console.error, + }; + + const vats = { + llm: undefined, + vectorStore: undefined, + }; + + const messageHistory = []; + const pushMessage = (message) => messageHistory.push(message); + const getConversation = (interlocutor) => + messageHistory.filter(({ sender, recipient }) => + [sender, recipient].includes(interlocutor), + ); + const getTrust = (interlocutor) => trust[interlocutor]; + + const proposeNextMessageResponseSchema = { + $schema: 'http://json-schema.org/draft-04/schema#', + $id: 'https://deepseek.io/conversation-response.schema.json', + title: 'Proposed Response', + description: + 'This document records a proposed next message in a conversation', + type: 'object', + properties: { + responder: { + description: 'Who will give the response', + type: 'string', + }, + justification: { + description: + 'An explanation for why this response is proper in the context', + type: 'string', + }, + proposedResponse: { + description: 'The proposed response', + type: 'string', + }, + }, + }; + + /** + * Validate that the JSON response meets its schema, given some parameters. + * + * XXX This validation logic is hardcoded. + * + * @param {*} response - The response to be validated. + * @param {*} params - Parameters for validating the response. + * @param parsedResponse + */ + const validateProposeNextMessageResponse = ( + parsedResponse, + { responder }, + ) => { + const parseFailures = []; + if (typeof parsedResponse.responder === 'undefined') { + parseFailures.push({ + problem: 'field:missing', + field: 'responder', + }); + } else if ( + parsedResponse.responder.toLowerCase() !== responder.toLowerCase() + ) { + parseFailures.push({ + problem: 'field:value', + field: 'responder', + expected: responder, + received: parsedResponse.responder, + }); + } + if (typeof parsedResponse.proposedResponse === 'undefined') { + parseFailures.push({ + problem: 'field:missing', + field: 'proposedResponse', + }); + } else if (typeof parsedResponse.proposedResponse !== 'string') { + parseFailures.push({ + type: 'field:type', + field: 'proposedResponse', + expected: 'string', + received: typeof parsedResponse.proposedResponse, + }); + } + if (parseFailures.length > 0) { + throw new Error('JSON parse failure', { cause: parseFailures }); + } + }; + + const maybeStripJSONTag = (content) => { + const [prefix, suffix] = ['```json', '```']; + let stripped = content.trim(); + if (stripped.startsWith(prefix)) { + stripped = stripped.split(prefix)[1]; + } + if (stripped.endsWith(suffix)) { + stripped = stripped.split(suffix)[0]; + } + return stripped.trim(); + }; + + const proposeNextMessage = async (responder, conversation, knowledge) => { + logger.debug( + 'user.proposeNextMessage:{args}', + JSON.stringify({ responder, conversation }, null, 2), + ); + + const [promptPrefix, promptSuffix] = [ + [ + `Read through this conversation and propose what ${responder} should say next.`, + JSON.stringify({ conversation }), + 'Include a justification for why the proposed response would be a good.', + ], + [ + 'Be sure to follow the instructions precisely and format your answer as valid JSON!', + ], + ]; + + const knowledgePlugin = + knowledge !== undefined && knowledge?.length > 0 + ? [ + `The following represents ${responder}'s current knowledge. You can use it in your response, but it may not be relevant.`, + JSON.stringify({ knowledge }), + '', + ] + : []; + + const schemaPlugin = [ + 'Give the answer in JSON matching the following schema.', + JSON.stringify(proposeNextMessageResponseSchema), + 'The following is an example of a valid response, although the content is intentionally nonsense.', + JSON.stringify({ + responder, + justification: `${responder}'s moon is in Aquarius.`, + proposedResponse: + "Now is the time to take that risk I've been forgoeing.", + }), + ]; + + let attempts = 0; + const failures = []; + const maxAttempts = 3; + + let response; + + while (attempts < maxAttempts) { + try { + logger.debug('user.proposeNextMessage:attempts', attempts); + const failurePlugin = + attempts > 0 + ? [ + `The following are examples of invalid responses, with the reasons for their invalidity.`, + JSON.stringify(failures), + ] + : []; + + const messages = [ + { + role: 'user', + content: [ + ...promptPrefix, + ...knowledgePlugin, + ...schemaPlugin, + ...failurePlugin, + ...promptSuffix, + ].join('\n'), + }, + ]; + logger.debug('user.proposeNextMessage:messages', messages); + + response = await E(vats.llm).chat(messages, false); + logger.debug('user.proposeNextMessage:response', response); + + const strippedResponse = maybeStripJSONTag(response); + logger.debug( + 'user.proposeNextMessage:strippedResponse', + strippedResponse, + ); + + let parsedResponse; + + try { + // Parse and validate the LLM's response against the JSON schema. + parsedResponse = JSON.parse(strippedResponse); + logger.debug( + 'user.proposeNextMessage:parsedResponse', + parsedResponse, + ); + } catch (problem) { + throw new Error('Response is not valid JSON', { + cause: { + type: 'format-invalid', + expected: 'JSON', + }, + }); + } + + validateProposeNextMessageResponse(parsedResponse, { responder }); + + // Return the proposed response as a string. + const toReturn = parsedResponse.proposedResponse; + logger.debug('user.proposeNextMessage:toReturn', toReturn); + return toReturn; + } catch (problem) { + attempts += 1; + logger.error( + `Response Generation Error: ${JSON.stringify({ + message: `${name} failed to respond (attempt ${attempts}).`, + cause: { message: problem.message }, + })}`, + ); + failures.push({ + response, + reason: problem.cause, + }); } + } + throw new Error( + `${name} failed to propose response to message after ${attempts} attempt(s).`, + ); + }; + + /** + * + * @param sender + * @param message + * @param conversationHistory + */ + async function processMessage(sender, message, conversationHistory) { + // Fallaciously assume the caller has truthfully self-identified. + const momentaryTrust = getTrust(sender); + const access = { secrecy: momentaryTrust }; + logger.debug('user.processMessage:access', access); + + const knowledge = await E(vats.vectorStore).retrieve( + message.content, + access, + ); + logger.debug('user.processMessage:knowledge', knowledge); + + const nextMessage = await proposeNextMessage( + name, + [...conversationHistory, message], + knowledge, + ); - console.log('initializing:', 'wiki'); - await E(vats.wiki).initModels(); - await E(vats.wiki).addDocuments(docs); - console.log('initialized:', 'wiki') - - console.log([ - '', - '-----\nUSER:\n-----', - prompt, - '-----', - '', - ].join('\n\n')); - - await E(vats.ollama).setWiki(vats.wiki); - const response = E(vats.ollama).chat(prompt); - - console.log([ - '', - '----\nLLM:\n----', - await response, - '----', - '', - ].join('\n\n')); + logger.debug(name, 'processed message', message); + return nextMessage; + } + + return Far('root', { + async init(llm, vectorStore) { + vats.llm = llm; + vats.vectorStore = vectorStore; + + await Promise.all([ + E(llm).init(), + (async () => { + await E(vectorStore).initModels(); + logger.debug(`${name}'s docs`, docs); + await E(vectorStore).addDocuments(docs); + })(), + ]); + + return { name, stream }; + }, + + async message(sender, content) { + const message = { sender, recipient: name, content }; + const conversationHistory = getConversation(sender); + pushMessage(message); + const response = await processMessage( + sender, + message, + conversationHistory, + ).catch((problem) => { + logger.error(problem); + return 'Error: bad brain'; + }); + pushMessage({ sender: name, recipient: sender, content: response }); + return response; + }, + async sendMessageTo(content, recipient) { + pushMessage({ sender: name, recipient, content }); + return await E(recipient).message(name, content); }, }); } diff --git a/packages/nodejs/src/demo/rag/vats/vectorStore.bundle b/packages/nodejs/src/demo/rag/vats/vectorStore.bundle new file mode 100644 index 000000000..3fc9c17f1 --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/vectorStore.bundle @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"de2526f10d90bbe59e7a48c139fb7da3bbcf2edca2163ec623a445c47388c1f6b61ef242a9a6bf2986c7098a405f78eda75bc6a001b469318f2476290114c815"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/vectorStore.js b/packages/nodejs/src/demo/rag/vats/vectorStore.js new file mode 100644 index 000000000..bc9636689 --- /dev/null +++ b/packages/nodejs/src/demo/rag/vats/vectorStore.js @@ -0,0 +1,67 @@ +import { Far } from '@endo/marshal'; + +/** + * Build function for the vector store vat. + * + * @param {unknown} vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} vatPowers.vectorStore - A vectorStore power. + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(vatPowers, parameters, _baggage) { + const { model, verbose } = parameters; + const { getVectorStore, ollama } = vatPowers; + const vectorStore = getVectorStore(); + + const logger = { + log: console.log, + debug: verbose ? console.debug : () => {}, + error: console.error, + }; + + return Far('root', { + async initModels() { + await ollama.pull({ model }); + }, + async addDocuments(docs) { + logger.debug( + 'vectorStore.addDocuments:docs', + JSON.stringify(docs, null, 2), + ); + // By default, every stored document is maximally private. + await vectorStore.addDocuments( + docs.map((doc) => ({ + pageContent: doc.pageContent, + metadata: { + ...doc.metadata, + }, + })), + ); + }, + /** + * Retrieve from the vectorStore a list of fragments similar to the topic. + * + * @param {*} topic - A string to query against. + * @param {*} accessCapability - An object representing the inquirer's access to stored fragments. + * @returns A list of accessible documents relevant to the query. + */ + async retrieve(topic, { secrecy }) { + // By default, do not retrieve anything but public information. + const access = (doc) => { + logger.debug('vectorStore.retreive.access:doc', doc); + const permit = doc.metadata.secrecy <= secrecy; + logger.debug('vectorStore.retreive.access:permit', permit); + return permit; + }; + // Search for the most similar documents + logger.debug('vectorStore.retrieve:topic', topic); + const results = await vectorStore.similaritySearch(topic, 3, access); + logger.debug('vectorStore.retrieve:results', results); + return results.map((document) => ({ + pageContent: document.pageContent, + metadata: { source: document.metadata.source }, + })); + }, + }); +} diff --git a/packages/nodejs/src/demo/rag/vats/wiki.bundle b/packages/nodejs/src/demo/rag/vats/wiki.bundle deleted file mode 100644 index 869227cea..000000000 --- a/packages/nodejs/src/demo/rag/vats/wiki.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAABRkd5uCzsAAAs7AAAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgInRhZ3MiOiBbXSwKICAiZW50cnkiOiB7CiAgICAiY29tcGFydG1lbnQiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAibW9kdWxlIjogIi4vc3JjL2RlbW8vcmFnL3ZhdHMvd2lraS5qcyIKICB9LAogICJjb21wYXJ0bWVudHMiOiB7CiAgICAiQGVuZG8vY29tbW9uLXYxLjIuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vY29tbW9uIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2NvbW1vbi12MS4yLjgiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vY29tbW9uLXYxLjIuOCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL29iamVjdC1tYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAib2JqZWN0LW1hcC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjEwZTA4YzE4NzZiODQzYzFmMDAyNzdmNmQzNGRkYTNiZDkzMjlkZTZhOWYwOTMxMzU4MjAxZjEwMDRjMmYzYTY0MTg5ZjZmZjBlYWJmZjhiYzU2MjRkNDAyYzFlN2M1NzJlNmFhM2JlYmI5MzM4ZjIzNzVmM2Y4MzFhYmEzOGYyIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2Vudi1vcHRpb25zIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQxNzc2ZWViMjFiMWM1NTFkYTNmOWI4ZGNkZjVhYmQ4OGJjYmY1ZjhlMzhjYjA0ZWRhYmM4Y2I5NjRiYjk3NTE4ZmY0Y2FjYjc0M2U4YWJiYWFjMjI4NjE2ODE1ZmJlNDBlODZiZTJkN2Q0MjgxNTc4OTUyZjhhYTg2NmExYjk3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vudi1vcHRpb25zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbnYtb3B0aW9ucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjljZWIxMmRlNmQ2MWE2MzQwNzg1NTI4NmU1ZTEwNzgzYjUyZDUzNGIxNWVlYjY0OWI5ZTU2MWQxMDY3MDc0ODUxOTJlOTc5MTQxYjQyMjU5ZTY0Njk5YjY2MWI4OTNmNDQyNDVkMTFjNGFhYTA3MGUxOTM4NDBmM2I3ZWQxYWU0IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9lcnJvcnMtdjEuMi44IjogewogICAgICAibmFtZSI6ICJAZW5kby9lcnJvcnMiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxZmQ0MTdiY2RiZGFlYzY5ZGExYWRkZWJiNTFmNjU5YmI4YjMxNWRjMWM5NmI3ZjcxMTU2YzU1NjJmMTdjZDkxOGNjYTA5ZGJmMDIxMmNjYmUxMWRkOTBhYjMzYTUxYjlkMTllYTMzY2ExOTNkMTY2NTI0ZTczYjMyYmEzNTVjMiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmM5ZDk3ZDA3OTRlYWU4NjhmM2Q2Y2RhYjFkNWNiYjk1ZmU1NjZlYzBhYThmMzFmYzdkNzhlMTBkOTUzNTllYjE2MmQ2NjE4ODIyZWEyMDVkYjUyYzI1ZGZiOTY4MGYxZDA5MGZmYjFmNGE0ZWM4Y2YxYmZhODM1ZjY1ZDZiYjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZXhwb3J0cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXhwb3J0cy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xvY2FsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9sb2NhbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk2YTQ4MWI2M2NjMzQxMDU0NTBhYWI0M2E2ZmJiNDAwYTYyNTdhMDgzN2VjMzMzZDM1ODJkMDIyNDJkYzg1MDgzZWUyYjFkOWZjM2RkMTBjOWEyNDg2MmU1NmUyNDkxODEyY2UxN2ZkMDMzNGM2MWFmNGZiMjA5ZjNmN2Y2YTQzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzc4YmJjYjcxNWVmOTM5ZGZmNjdhNTI2YzlhMGIyMmEwYTMyMDBkMTBjOTczZDhkYzFlZWI5N2NmNTY4NTVlNDk2ZDNiODg0Mjc2NGMyMTRlZGU1MWUxZGJlMjUzNzVkYTAxMjFhNjg4ZjNiOGMxZDFmN2M5YTYzYzE0ZDM2MSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9uby1zaGltLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9uby1zaGltLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGFjNWNiYjQ0N2NjNTk5ZDUxYTk2NGUyODVlMjljMDliYmI5MDdkNzJhYjY1MzNhMmQ5MzJmNTFjYzc4NWMwY2ZmOTMwMDNjNWJmNWRiMTE2MWQzNWMzY2ZhM2JmNTJhNGI4OGM4NjVjZTVmYjg0ZjU4MzIzNjczNWJmNWFiMjgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHJhY2stdHVybnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RyYWNrLXR1cm5zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2IwMjE3N2Y1NDVmNWE2Y2ExNDRiOGVhM2M4MzJjODk4NzExZThlYTJjZjU0Mzk1OWY1YTViYjcxMjRlNWYwNDdlNDljMDFkOGY1MThkNThkMDAzY2ZhZDQyODY3NGRjNDVkNWY1MTBlNGE0ZjRiNTE0ZGNkNWE3NTFjM2U1NmYiCiAgICAgICAgfSwKICAgICAgICAiLi91dGlscy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJ1dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImZlYTA0MTFiMjE2YzcxNDE1MTQzOTY2NjRmOGY4MjEzYWNkMTEyZTkzMGMwZjRmYWMwMzQyN2Y1NzM3ZDczN2QwZTk0NmI2Y2M0YzYwODg0ZDA0MDU3Yjc3Zjg4MDhhMzk2NzM2ODU5NTU4ODcyNDM1ZWFlZWVkMmYxMzI2NDdkIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9tYXJzaGFsLXYxLjYuMiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbWFyc2hhbCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9tYXJzaGFsLXYxLjYuMiIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jb21tb24tdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9vYmplY3QtbWFwLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Vycm9ycyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lcnJvcnMtdjEuMi44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY1LjAuMTMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5NzFhNGJhZjkyYjU0OGUyNDc0ODgwYzA3ZGFiZjM2MWYyZmQwMzhjNDAwZGE1MWQwYTQ0NjgwOTJlMzY1NTU3Njk3YzhlYjFjYWUzMjVjZmQ5ZmFmNzJhYjg2YzEzZjA0MjQwYTZlMTQ3M2E3ZTM5Mzg2MmRkMDQxMWI1NGUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVBhc3NhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjBkYWNmYTE3YTA1ZmU0M2IwY2FkY2QxODYzMGRiZjU4NmJkMjRkYTQ0YTc4ODU5MDAyNTUxMWVkOGRlZmEwZjEyOWQ3YjI0M2I1YjljZjA2MzAzZTQxNGNlN2I3NzZmOTA4NzgwZDE1NGJkOTI4NTU3MDFhOTgyMGQxMWQ5MWIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb0NhcERhdGEuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlMjEzNzVlYzUxNGEyYjAxMDVjYzJmYmRlY2IzNWJiNTE5OWIyMmZmZjY5MjkwOWIzNGM4NGJmYzE2ZDc5OTBlZjVkMzQyY2I1ZjAyYzZhMzI1N2IwN2E4Y2EzNjJjNmEyMzE1MjJiODg5ZjgxZDQ2ODVhNDYwN2ZiZDg0OTcwYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlVG9TbWFsbGNhcHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNTU4Y2EwZTNhOTcwZjQzZWRlYzdhOTY5NTA2YmQ4MWU0ZDllZmNkOWVlZGFjZDg3NDcyZTFmYzQ1ZDAyMmFlZDAzZjcxMmJjYTUxYTJkN2VjMTQ5MjllNWZlMDg4MjM2NDM3OTIwNDEzYjM1Y2EwZjk4NTdlZjExODE2ZmNmNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1qdXN0aW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2ZTQxOTY2OWYyN2RmMjI1MWUwMWNlMTU4NmVkYzVmNzI0YjNjNjgxOTM5MzE2NjA2ZDU0OWRmY2ZjOTllMDk2MjZjMTllNDY3MGY0ZDc1MmM3OTRiMGYxOTczOTFjYzBiZDM3NTdjYzNkYWVkZGE5NzJkN2Y0NTY4MmQzZWYxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0NGNmNmRiZWY1MzliYjQ5YTdhZTFlODkzZGZmNGVlYmQ4NWJmNzE4MTdhZDczODg1YzUxMmY4NjBhZWFmOTJlNzQ3ZWZlMzg2N2ExZjg4YzY4YTFiMmYwMjc5YjRiNmE0MjQzMWYwNWMzNWEzNTdhM2ZlMzdhNjRjMTY1YmQzOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYTdlMzgxYjcxNDBkNTM5Y2U2Yjg0NThlYWU3ZTcyZjM4ZTUyNDgxMjhhYmYyMWU5ZjU2OGI1NDY0ODlhMjYzY2JkYWNhMmIzNGE0NTcxNDgyNzA4OWI3NDk3MzgwZDNhYTA2NjY5YjVkZGE3NjhkMzljODE5YjhkODdlM2NlYzgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmFua09yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yYW5rT3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwOTY2MzNlODZjMDk2ZmYzMjhlMjM0NDJmYWU0ZWVhZWJkNjlmNDhlODQzM2RkOTlkODU0YmJkOGI3MDM3YzgzNjM0MmRiNjI4OTYzYWFjYTE5YzIxNzIwMTViNjhjZjk5MWJmMTRiMTVhM2IwOWYzM2YwMGEzZDI0ZWJlZTEyNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1NDY1NWU4NTkzMTk4ODQ3MGJkZGFiMWZlZjU1NmVmOGJmYjdlMjYyNTBiNmVlZTQ1NTYwZDgwZWQxZTNlZjhkNWJiOGU1ZDA1OGI2MDg1ZWNlMmUxN2FmMjE2ZDgzYWE5MzkwNzBlNGUyYzE5NTI1ODk4NmI3MzYwOTlmYWQ5YyIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vbmF0LXY1LjAuMTMiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL25hdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9uYXQtdjUuMC4xMyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlYzQyZTI2NjMyYmJhYjRiYzhmNTkxN2Q3MmYwNzQyM2MxNjI2NGYyZDZhMjBmNmRlOGQxODk2NjZhM2VmMTk2NjhiNmJkNTdlZTYzODM1MmY4OGQ5YzY5Mjk5OGFmZTY4YjUxM2E4YzMzYmY2ODJkODZhZmUwM2ExZTEzYTdlYiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Bhc3Mtc3R5bGUiLAogICAgICAibGFiZWwiOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vcGFzcy1zdHlsZS12MS40LjciLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9lcnJvcnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXJyb3JzLXYxLjIuOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdXRpbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjk5MzJkNTRmNWI0MWFjN2IyNDFiMDQ0N2RlYmI1Zjc5MzU5YTRjYWM1MmQ3Y2I2ODQ1NTRkMjUxNTE5OWI5OWE0NWYwMWZlYzkyYWNhNDdhYTViNzE1OWU0ZWRiOTRhYzdjYzRiMWJhODYxNWIyMzk0NDI4ODFlZDg5MGZlMTUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29weUFycmF5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5QXJyYXkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMTk4YTI4ODUyYjRjYTM2OGJmODdmYTg0ZDcwYmM3YmNmOTUwZGM1Y2Y2MzUyYWY2YzFhOTg3YzE2ZTc3NDkxMDQ4NTFhNDUyMGMxZjMyNzZiZDk1ZDIwZGEyNzU4ZTRhNDM0MWUwOTI4NjQ4YzlmY2QzOTBjNDRhZGMyMjQ0MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb3B5UmVjb3JkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb3B5UmVjb3JkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmExMTgzYzI4ZmU1N2MyNjM3MmZhNWI5NDRhMzg1NzZkNWRhNmQ5MzIwYWZmNzY0YWFlODkxNjRhNWEwNGE1NzNmYWI5ZGRiOWY2YzJjZTk2NWUxMjFkYmRmYWNkYWM0MzE0NDMzOWUzODM4MzY4YzkyMWI0YjY3YTNlZjgzOTgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9kZWVwbHlGdWxmaWxsZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5MDY3Yjc1OWYyNGQ0OWEzOTc4Y2M5NGQzMDZiNjJlZDFlZmQyM2M3NmU0YzFhMjI2NDhjMzVhN2NkMjcxZTg1ZTYzZGNmNTNhZjdmNWZhMjA3YjNlMzQ5YjgwNTdkYzBjMjM5OTcwNjgwNTNlZmE5YzZmYzY5N2Q0YzBlNWQzYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lcnJvci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXJyb3IuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyNGViNDFhZmI3OTc2YmI3YTNmNDVkMjk1NGVlY2FhNWEzMzIwN2ZmMzBiNjhmMGEzZDcxZGJkNWY0ZWU1MDQ1ZTg4NzA4MmY1OGYwNDM2MTgxOTZkMzA5YjFlNTUyNTMxMjVlMjBiYmRiMjJmYTAyNzgyYTE0ZWRjM2JlNGZmMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pdGVyLWhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2l0ZXItaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdlNGM5NjA4ZDE1ZDYzYTdjYzc1ODIyYWE3MGRiNGE3NzMwZjMyZTBjYzZhYTRiZDNiOTAwYjA1Mjk4ZTU3YjE1NTljOTY1YjU0OTJlNGE4NWY4YTIwYTc2N2RmZjJlMTcwNThkMDg3NTEzYzY4NTI2MGY0NWNmOTJiYjIwY2RjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2UtZmFyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYWtlLWZhci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjUyNmU2OTgxMzc1MjE4ZDA3YmZlNWMzYjhjMjg3ZGMyMDVlYTBkNTU5NjRjYmMyMWJjYWZiNzMxOWE2YTg5MGRkNTU1M2ViZmRjN2EzMjM2MTQxYTFkNzVlNzVhOTcyOGUwMzUyZTc2NTU0N2E0NDI3OWE1ZGNmN2EzYjVlYzU3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2VUYWdnZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2VUYWdnZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4YTU3ZjRmMTg3MTE0NjhkODFlMzBlODJiYzYwZTQ3MDQyMDI2ODFmMjY5NGFkM2IwNzUzY2IzYmQyMWNmOWQ0OWQ3OGYyNzliYWU0ZjlkMTI5Njg3MzJkNDYxOTU1ODZkOTcyNzNhZGFmNGQ3NmY4ZWJmNDA4MjQyM2IwMTgxNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNGJmMmNkNjVlYTI1NGVlYjMyZWQ4MDI5ZTEzNTBkOGE4MTJiM2EzM2VkMGMyYzkxYzcxZDhjNzRhOTlmYWZhM2UwMjIwMTAzZjY5NWIwN2RiMTYxMjI3YWJhNjNhMWE5YWIwNzU4N2M0NTNhNThhMDA5Yjk0NWQ0MjFmZTJiMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGVPZi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlT2YuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjYTI3NTA3YzU4MjhmMzQ3ZWFmMmYyNzVkNjY5NzEyNDVlYmUyZGRlNjk0NjMwODJjMjE1ZTc3ZDAyNjZmZThmZjBjYTA4MTQwZjk4ZTljNDIyYTAxNjJlNjc3MTE3YzkwNGM5MzczNzRiNmUzNTNiYjVhODA3NzU1MGEzZTQwMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yZW1vdGFibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JlbW90YWJsZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc0MWU1ODdkYmJmNTY4OTRhMDFmNzdhMmNlM2RmOTBmZGQ5MmNjN2RiMDExMDY0MmY5NDY0NGQ2NTRhZTI3MmIzZTRmZjFkODEwNGMzZWI5NmIxMzI0ODg3YzdkNjhiMzQxNjEyODI3ZDAzMTQxOGU5OGI3NjM0Y2M5MDE0M2VkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3NhZmUtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc2FmZS1wcm9taXNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjE4YjZmYWJlODY3MzRmMWU5ZTEwZTkyMjA1MWY3MGYyMzY4ODFiMWZlODg5YjI2MTQ1OTY4ZjBiYThiNmQ4ZGEwZTAyMjk4MDk5ZGY2OGM1YzA1MjViZGY5NDUwYTkyOTdkM2Q5MjY3ZjczNjk2NDIwOGJkYzM5YTAwNjNlMjciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RyaW5nLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zdHJpbmcuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhNWY4ZjYwZGEzNzVjNGRkNTQ1YWY2MTEwYzY2OWM0MDI0ODI2YzIwZWIxYWU4ZDkyYTNiMDEyNzVjN2Q2Y2VhM2RhZDZiOTI0MjVlNjAzZTQ2NzczZWM3MzA2NTM1OWE2MThjNTdlYWJiMTVlNWZhOTA5MWNmYjJkMDMxNjEwZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zeW1ib2wuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N5bWJvbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImM1Mzc0MDgxNDdhNzIzOGRlZDFjMzczZTZlZTZiYWYzNDNkYTdkMmM0YzU5NTJmMjMwMjU2MDFlNThlNTdmMjJiMzI1OWZhMDIyYWNlNjk0YjVjMjg5MDY3ZGIxZmZkZmQyMjk2NDJmYzBiMzlkOTcxNmJmZmE5MGVmMjJkZjBkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdGFnZ2VkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjU3NWQxNDUxZjQ3ZWIzZDg4YzU0MzVkZTE5NGUwZjc2M2Q3NDc2M2EzMzE3YzNhYTE1Zjc2ZjQ1MjQzY2E5MTA2NmViYzk2YWYxZTk3MjA0MDNkYWVlZmRiMjU4NmY3MzFiZWVhMjM0MzBmMDg3Njc3ZDQzZjFlM2RjNWMyZjAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5YzdhOWM0NGUxY2MxNmM1Nzg1N2NjNzJkZjgxMWY5YjZjMjZlYzllNjMwZDhiYjEzMWFiYmU4NWUyZjQ3OWQxMTJhNDU0N2YyNDAxNzk0Nzg2MTNjZjk3ZTQ1NDE4MzAwN2FjNTQ4MDBiMWE4ZDU2MTc4ZjE4ODBlYWMwNWE2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Byb21pc2Uta2l0IiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wcm9taXNlLWtpdC12MS4xLjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImFmNDk2MmU0ODNkODRjODdmZDliNzk1ZDdkM2ViYzRkZTIwM2Y5NGQ1MDQxODhjY2VmNDFmZjA5ZGUwYmVmNTI1NDNmNGYzMTNjYTE5ZWMxN2ZjYzRiOGNkODg3NzhhYWQ2ZjY0YzgxMDFkODM3NDc4ZDhiNTk0YTEwNjZjOTdjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2lzLXByb21pc2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2lzLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NzczMTVhNTE2MjM1YTAyMDQ4YjNjNGRmMTA3MWM4YmYxZjFkZTkwM2Q0Y2U4YTkyYzk1OGUxZTBjNzI2NGVkZDIyZjU3NjE5OWYyZjEzOWViMWZkNjI3MDVhODUzNmU3NTAyZTM4ODZjYTNmNWYyODkzMTI0YmU4M2E0YzlhNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tZW1vLXJhY2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lbW8tcmFjZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY0ZWZjOGY0ZGE2MDBhMzEyNmQyN2NkNTBhYjAxNzAyNTAzMGMyZjI0Yzk5YWExODFiNTJhODRkZDEzNGIxODcxNjkxMzVlNjZlZjJlYjYzNjMwYmVmNzYwNzQ4MzM3NzdjNDUzMGYyM2E5NDdhMzNkYzg1MDMyN2YxNTQzOGNlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjRlMmM0YjVjZGUzOGUxZjQ2ZmNiMDAxYTQyNzQ1YTgyMzIxNDhlNTMxZDc2ZWM5NmE2YWM5NmNhODVlNjE4MDM1MjgyNzE5MzAxNTUzMGU2ZjUyYzQ5NTFjN2Y1NmEzYWRiNjFmNjlmMmM1OWU1NzEyZGE5NjY1MThiMzk3OTc1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0NjU1ZTg1OTMxOTg4NDcwYmRkYWIxZmVmNTU2ZWY4YmZiN2UyNjI1MGI2ZWVlNDU1NjBkODBlZDFlM2VmOGQ1YmI4ZTVkMDU4YjYwODVlY2UyZTE3YWYyMTZkODNhYTkzOTA3MGU0ZTJjMTk1MjU4OTg2YjczNjA5OWZhZDljIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAb2NhcC9ub2RlanMtdjAuMC4wIjogewogICAgICAibmFtZSI6ICJAb2NhcC9ub2RlanMiLAogICAgICAibGFiZWwiOiAiQG9jYXAvbm9kZWpzLXYwLjAuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAb2NhcC9ub2RlanMtdjAuMC4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MS42LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlbW8vcmFnL3ZhdHMvd2lraS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGVtby9yYWcvdmF0cy93aWtpLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDNlODEwNjVhYmQ3Y2U2YmNiYTE2NTE4OWU1Zjg0YjYwYjQwZmExYmM0ODQyNTk1NDMzNWUzNTc1ZjBhM2Q4ODU3OGU4NjRiYzQ2ZDQ0YTBhZjUwNTFhNjZhYTM2NGE4NWQ0NzNkMzRkNGM0ZWFjMmEyZWJiYjk4MTZjMjRlYjQiCiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9UEsDBAoAAAAAAAAAAADCcMNqPQoAAD0KAAAhAAAAQGVuZG8vY29tbW9uLXYxLjIuOC9vYmplY3QtbWFwLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJvYmplY3RNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIGNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBCeSBhbmFsb2d5IHdpdGggaG93IGBBcnJheS5wcm90b3R5cGUubWFwYCB3aWxsIG1hcCB0aGUgZWxlbWVudHMgb2ZcbiAqIGFuIGFycmF5IHRvIHRyYW5zZm9ybWVkIGVsZW1lbnRzIG9mIGFuIGFycmF5IG9mIHRoZSBzYW1lIHNoYXBlLFxuICogYG9iamVjdE1hcGAgd2lsbCBkbyBsaWtld2lzZSBmb3IgdGhlIHN0cmluZy1uYW1lZCBvd24gZW51bWVyYWJsZVxuICogcHJvcGVydGllcyBvZiBhbiBvYmplY3QuXG4gKlxuICogVHlwaWNhbCB1c2FnZSBhcHBsaWVzIGBvYmplY3RNYXBgIHRvIGEgQ29weVJlY29yZCwgaS5lLixcbiAqIGFuIG9iamVjdCBmb3Igd2hpY2ggYHBhc3NTdHlsZU9mKG9yaWdpbmFsKSA9PT0gJ2NvcHlSZWNvcmQnYC4gRm9yIHRoZXNlLFxuICogbm9uZSBvZiB0aGUgZm9sbG93aW5nIGVkZ2UgY2FzZXMgYXJpc2UuIFRoZSByZXN1bHQgd2lsbCBiZSBhIENvcHlSZWNvcmRcbiAqIHdpdGggZXhhY3RseSB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lcywgd2hvc2UgdmFsdWVzIGFyZSB0aGUgbWFwcGVkIGZvcm0gb2ZcbiAqIHRoZSBvcmlnaW5hbCdzIHZhbHVlcy5cbiAqXG4gKiBXaGVuIHRoZSBvcmlnaW5hbCBpcyBub3QgYSBDb3B5UmVjb3JkLCBzb21lIGVkZ2UgY2FzZXMgdG8gYmUgYXdhcmUgb2ZcbiAqICAgICogTm8gbWF0dGVyIGhvdyBtdXRhYmxlIHRoZSBvcmlnaW5hbCBvYmplY3QsIHRoZSByZXR1cm5lZCBvYmplY3QgaXNcbiAqICAgICAgaGFyZGVuZWQuXG4gKiAgICAqIE9ubHkgdGhlIHN0cmluZy1uYW1lZCBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIG9mIHRoZSBvcmlnaW5hbFxuICogICAgICBhcmUgbWFwcGVkLiBBbGwgb3RoZXIgcHJvcGVydGllcyBhcmUgaWdub3JlZC5cbiAqICAgICogSWYgYW55IG9mIHRoZSBvcmlnaW5hbCBwcm9wZXJ0aWVzIHdlcmUgYWNjZXNzb3JzLCBgT2JqZWN0LmVudHJpZXNgXG4gKiAgICAgIHdpbGwgY2F1c2UgaXRzIGBnZXR0ZXJgIHRvIGJlIGNhbGxlZCBhbmQgd2lsbCB1c2UgdGhlIHJlc3VsdGluZ1xuICogICAgICB2YWx1ZS5cbiAqICAgICogTm8gbWF0dGVyIHdoZXRoZXIgdGhlIG9yaWdpbmFsIHByb3BlcnR5IHdhcyBhbiBhY2Nlc3Nvciwgd3JpdGFibGUsXG4gKiAgICAgIG9yIGNvbmZpZ3VyYWJsZSwgYWxsIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogICAgICBub24td3JpdGFibGUsIG5vbi1jb25maWd1cmFibGUsIGRhdGEgcHJvcGVydGllcy5cbiAqICAgICogTm8gbWF0dGVyIHdoYXQgdGhlIG9yaWdpbmFsIG9iamVjdCBtYXkgaGF2ZSBpbmhlcml0ZWQgZnJvbSwgYW5kXG4gKiAgICAgIG5vIG1hdHRlciB3aGV0aGVyIGl0IHdhcyBhIHNwZWNpYWwga2luZCBvZiBvYmplY3Qgc3VjaCBhcyBhbiBhcnJheSxcbiAqICAgICAgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGFsd2F5cyBiZSBhIHBsYWluIG9iamVjdCBpbmhlcml0aW5nIGRpcmVjdGx5XG4gKiAgICAgIGZyb20gYE9iamVjdC5wcm90b3R5cGVgIGFuZCB3aG9zZSBzdGF0ZSBpcyBvbmx5IHRoZXNlIG5ldyBtYXBwZWRcbiAqICAgICAgb3duIHByb3BlcnRpZXMuXG4gKlxuICogV2l0aCB0aGVzZSBkaWZmZXJlbmNlcywgZXZlbiBpZiB0aGUgb3JpZ2luYWwgb2JqZWN0IHdhcyBub3QgYSBDb3B5UmVjb3JkLFxuICogaWYgYWxsIHRoZSBtYXBwZWQgdmFsdWVzIGFyZSBQYXNzYWJsZSwgdGhlbiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqIGEgQ29weVJlY29yZC5cbiAqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIGFueT59IE9cbiAqIEB0ZW1wbGF0ZSBSIG1hcCByZXN1bHRcbiAqIEBwYXJhbSB7T30gb3JpZ2luYWxcbiAqIEBwYXJhbSB7KHZhbHVlOiBPW2tleW9mIE9dLCBrZXk6IGtleW9mIE8pID0+IFJ9IG1hcEZuXG4gKiBAcmV0dXJucyB7UmVjb3JkPGtleW9mIE8sIFI+fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKFxuKFtrLHZdKT0+LyoqIEB0eXBlIHtba2V5b2YgTywgUl19ICovW2ssbWFwRm4odixrKV0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7UmVjb3JkPGtleW9mIE8sIFI+fSAqL2hhcmRlbihmcm9tRW50cmllcyhtYXBFbnRzKSkpO1xuIH07JGjNj19vbmNlLm9iamVjdE1hcChvYmplY3RNYXApO1xuaGFyZGVuKG9iamVjdE1hcCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJvYmplY3RNYXAiOlsib2JqZWN0TWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUY5zqUAQAAlAEAACEAAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW52LW9wdGlvbnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy9lbnYtb3B0aW9ucy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvZW52LW9wdGlvbnMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAXZuU6h4TAAAeEwAAKwAAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9zcmMvZW52LW9wdGlvbnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiLCJnZXRFbnZpcm9ubWVudE9wdGlvbiIsImdldEVudmlyb25tZW50T3B0aW9uc0xpc3QiLCJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtY2hlY2sqL1xuXG4vKiBgQGVuZG8vZW52LW9wdGlvbnNgIG5lZWRzIHRvIGJlIGltcG9ydGVkIHF1aXRlIGVhcmx5LCBhbmQgc28gc2hvdWxkKi9cbi8qIGF2b2lkIGltcG9ydGluZyBmcm9tIHNlcyBvciBhbnl0aGluZyB0aGF0IGRlcGVuZHMgb24gc2VzLiovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cbi8qIFByZWx1ZGUgb2YgY2hlYXAgZ29vZCAtIGVub3VnaCBpbWl0YXRpb25zIG9mIHRoaW5ncyB3ZSdkIHVzZSBvciovXG4vKiBkbyBkaWZmZXJlbnRseSBpZiB3ZSBjb3VsZCBkZXBlbmQgb24gc2VzKi9cblxuY29uc3R7ZnJlZXplfT1PYmplY3Q7XG5jb25zdHthcHBseX09UmVmbGVjdDtcblxuLyogU2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gdGhlIG9uZSBpbiBzZXMnIGNvbW1vbnMuanMgZXZlbiB0aG91Z2ggaXQqL1xuLyogdXNlcyB0aGUgb3RoZXIgdGVjaG5pcXVlLiovXG5jb25zdCB1bmN1cnJ5VGhpcz1cbihmbik9PlxuKHJlY2VpdmVyLC4uLmFyZ3MpPT5cbmFwcGx5KGZuLHJlY2VpdmVyLGFyZ3MpO1xuY29uc3QgYXJyYXlQdXNoPXVuY3VycnlUaGlzKEFycmF5LnByb3RvdHlwZS5wdXNoKTtcbmNvbnN0IGFycmF5SW5jbHVkZXM9dW5jdXJyeVRoaXMoQXJyYXkucHJvdG90eXBlLmluY2x1ZGVzKTtcbmNvbnN0IHN0cmluZ1NwbGl0PXVuY3VycnlUaGlzKFN0cmluZy5wcm90b3R5cGUuc3BsaXQpO1xuXG5jb25zdCBxPUpTT04uc3RyaW5naWZ5O1xuXG5jb25zdCBGYWlsPShsaXRlcmFscywuLi5hcmdzKT0+e1xubGV0IG1zZz1saXRlcmFsc1swXTtcbmZvcihsZXQgaT0wO2k8YXJncy5sZW5ndGg7aSs9MSl7XG5tc2c9IGAke21zZ30ke2FyZ3NbaV19JHtsaXRlcmFsc1tpKzFdfWA7XG4gfVxudGhyb3cgRXJyb3IobXNnKTtcbiB9O1xuXG4vKiBlbmQgcHJlbHVkZSovXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogYG1ha2VFbnZpcm9ubWVudENhcHRvcmAgcHJvdmlkZXMgYSBtZWNoYW5pc20gZm9yIGdldHRpbmcgZW52aXJvbm1lbnRcbiAqIHZhcmlhYmxlcywgaWYgdGhleSBhcmUgbmVlZGVkLCBhbmQgYSB3YXkgdG8gY2F0YWxvZyB0aGUgbmFtZXMgb2YgYWxsXG4gKiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQgd2VyZSBjYXB0dXJlZC5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gYUdsb2JhbFxuICogQHBhcmFtIHtib29sZWFufSBbZHJvcE5hbWVzXSBEZWZhdWx0cyB0byBmYWxzZS4gSWYgdHJ1ZSwgZG9uJ3QgdHJhY2tcbiAqIG5hbWVzIHVzZWQuXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW52aXJvbm1lbnRDYXB0b3I9KGFHbG9iYWwsZHJvcE5hbWVzPWZhbHNlKT0+e1xuY29uc3QgY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzPVtdO1xuXG4vKipcbiAqIEdldHMgYW4gZW52aXJvbm1lbnQgb3B0aW9uIGJ5IG5hbWUgYW5kIHJldHVybnMgdGhlIG9wdGlvbiB2YWx1ZSBvciB0aGVcbiAqIGdpdmVuIGRlZmF1bHQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbk5hbWVcbiAqIEBwYXJhbSB7c3RyaW5nfSBkZWZhdWx0U2V0dGluZ1xuICogQHBhcmFtIHtzdHJpbmdbXX0gW29wdE90aGVyVmFsdWVzXVxuICogSWYgcHJvdmlkZWQsIHRoZSBvcHRpb24gdmFsdWUgbXVzdCBiZSBpbmNsdWRlZCBvciBtYXRjaCBgZGVmYXVsdFNldHRpbmdgLlxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZ2V0RW52aXJvbm1lbnRPcHRpb249KFxub3B0aW9uTmFtZSxcbmRlZmF1bHRTZXR0aW5nLFxub3B0T3RoZXJWYWx1ZXM9dW5kZWZpbmVkKT0+XG57XG50eXBlb2Ygb3B0aW9uTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYEVudmlyb25tZW50IG9wdGlvbiBuYW1lICR7cShvcHRpb25OYW1lKX0gbXVzdCBiZSBhIHN0cmluZy5gO1xudHlwZW9mIGRlZmF1bHRTZXR0aW5nPT09J3N0cmluZyd8fFxuRmFpbCBgRW52aXJvbm1lbnQgb3B0aW9uIGRlZmF1bHQgc2V0dGluZyAke3EoXG5kZWZhdWx0U2V0dGluZylcbiB9IG11c3QgYmUgYSBzdHJpbmcuYDtcblxuLyoqIEB0eXBlIHtzdHJpbmd9ICovXG5sZXQgc2V0dGluZz1kZWZhdWx0U2V0dGluZztcbmNvbnN0IGdsb2JhbFByb2Nlc3M9YUdsb2JhbC5wcm9jZXNzfHx1bmRlZmluZWQ7XG5jb25zdCBnbG9iYWxFbnY9XG50eXBlb2YgZ2xvYmFsUHJvY2Vzcz09PSdvYmplY3QnJiZnbG9iYWxQcm9jZXNzLmVudnx8dW5kZWZpbmVkO1xuaWYodHlwZW9mIGdsb2JhbEVudj09PSdvYmplY3QnKXtcbmlmKG9wdGlvbk5hbWUgaW4gZ2xvYmFsRW52KXtcbmlmKCFkcm9wTmFtZXMpe1xuYXJyYXlQdXNoKGNhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcyxvcHRpb25OYW1lKTtcbiB9XG5jb25zdCBvcHRpb25WYWx1ZT1nbG9iYWxFbnZbb3B0aW9uTmFtZV07XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2Ygb3B0aW9uVmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gbmFtZWQgJHtxKFxub3B0aW9uTmFtZSlcbiB9LCBpZiBwcmVzZW50LCBtdXN0IGhhdmUgYSBjb3JyZXNwb25kaW5nIHN0cmluZyB2YWx1ZSwgZ290ICR7cShcbm9wdGlvblZhbHVlKVxuIH1gO1xuc2V0dGluZz1vcHRpb25WYWx1ZTtcbiB9XG4gfVxub3B0T3RoZXJWYWx1ZXM9PT11bmRlZmluZWR8fFxuc2V0dGluZz09PWRlZmF1bHRTZXR0aW5nfHxcbmFycmF5SW5jbHVkZXMob3B0T3RoZXJWYWx1ZXMsc2V0dGluZyl8fFxuRmFpbCBgVW5yZWNvZ25pemVkICR7cShvcHRpb25OYW1lKX0gdmFsdWUgJHtxKFxuc2V0dGluZylcbiB9LiBFeHBlY3RlZCBvbmUgb2YgJHtxKFtkZWZhdWx0U2V0dGluZywuLi5vcHRPdGhlclZhbHVlc10pfWA7XG5yZXR1cm4gc2V0dGluZztcbiB9O1xuZnJlZXplKGdldEVudmlyb25tZW50T3B0aW9uKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5jb25zdCBnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0PShvcHRpb25OYW1lKT0+e1xuY29uc3Qgb3B0aW9uPWdldEVudmlyb25tZW50T3B0aW9uKG9wdGlvbk5hbWUsJycpO1xucmV0dXJuIGZyZWV6ZShvcHRpb249PT0nJz9bXTpzdHJpbmdTcGxpdChvcHRpb24sJywnKSk7XG4gfTtcbmZyZWV6ZShnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTtcblxuY29uc3QgZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcz0ob3B0aW9uTmFtZSxlbGVtZW50KT0+XG5hcnJheUluY2x1ZGVzKGdldEVudmlyb25tZW50T3B0aW9uc0xpc3Qob3B0aW9uTmFtZSksZWxlbWVudCk7XG5cbmNvbnN0IGdldENhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lcz0oKT0+e1xucmV0dXJuIGZyZWV6ZShbLi4uY2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzXSk7XG4gfTtcbmZyZWV6ZShnZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXMpO1xuXG5yZXR1cm4gZnJlZXplKHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMsXG5nZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXN9KTtcblxuIH07JGjNj19vbmNlLm1ha2VFbnZpcm9ubWVudENhcHRvcihtYWtlRW52aXJvbm1lbnRDYXB0b3IpO1xuZnJlZXplKG1ha2VFbnZpcm9ubWVudENhcHRvcik7XG5cbi8qKlxuICogRm9yIHRoZSBzaW1wbGUgY2FzZSwgd2hlcmUgdGhlIGdsb2JhbCBpbiBxdWVzdGlvbiBpcyBgZ2xvYmFsVGhpc2AgYW5kIG5vXG4gKiByZXBvcnRpbmcgb2Ygb3B0aW9uIG5hbWVzIGlzIGRlc2lyZWQuXG4gKi9cbmNvbnN0ICAgICAgIHtcbmdldEVudmlyb25tZW50T3B0aW9uLFxuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCxcbmVudmlyb25tZW50T3B0aW9uc0xpc3RIYXN9PVxubWFrZUVudmlyb25tZW50Q2FwdG9yKGdsb2JhbFRoaXMsdHJ1ZSk7JGjNj19vbmNlLmdldEVudmlyb25tZW50T3B0aW9uKGdldEVudmlyb25tZW50T3B0aW9uKTskaM2PX29uY2UuZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdChnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0KTskaM2PX29uY2UuZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyhlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbnZpcm9ubWVudENhcHRvciI6WyJtYWtlRW52aXJvbm1lbnRDYXB0b3IiXSwiZ2V0RW52aXJvbm1lbnRPcHRpb24iOlsiZ2V0RW52aXJvbm1lbnRPcHRpb24iXSwiZ2V0RW52aXJvbm1lbnRPcHRpb25zTGlzdCI6WyJnZXRFbnZpcm9ubWVudE9wdGlvbnNMaXN0Il0sImVudmlyb25tZW50T3B0aW9uc0xpc3RIYXMiOlsiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADnjB5W6QwAAOkMAAAcAAAAQGVuZG8vZXJyb3JzLXYxLjIuOC9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiRmFpbCIsIlgiLCJhbm5vdGF0ZUVycm9yIiwiYXNzZXJ0IiwiYiIsImJhcmUiLCJtYWtlRXJyb3IiLCJub3RlIiwicSIsInF1b3RlIiwicmVkYWN0ZWQiLCJ0aHJvd1JlZGFjdGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogVGhpcyBtb2R1bGUgYXNzdW1lcyB0aGUgZXhpc3RlbmNlIG9mIGEgbm9uLXN0YW5kYXJkIGBhc3NlcnRgIGhvc3Qgb2JqZWN0LiovXG4vKiBTRVMgdmVyc2lvbiAwLjExLjAgaW50cm9kdWNlcyB0aGlzIGdsb2JhbCBvYmplY3QgYW5kIGVudGFuZ2xlcyBpdCovXG4vKiB3aXRoIHRoZSBgY29uc29sZWAgaG9zdCBvYmplY3QgaW4gc2NvcGUgd2hlbiBpdCBpbml0aWFsaXplcywqL1xuLyogYWxsb3dpbmcgZXJyb3JzLCBwYXJ0aWN1bGFybHkgYXNzZXJ0aW9uIGVycm9ycywgdG8gaGlkZSB0aGVpciBcImRldGFpbHNcIiovXG4vKiBmcm9tIGNhbGxlcnMgdGhhdCBtaWdodCBjYXRjaCB0aG9zZSBlcnJvcnMsIHRoZW4gcmV2ZWFsIHRoZW0gdG8gdGhlKi9cbi8qIHVuZGVybHlpbmcgY29uc29sZS4qL1xuLyogVG8gdGhlIGV4dGVudCB0aGF0IHRoaXMgYGNvbnNvbGVgIGlzIGNvbnNpZGVyZWQgYSByZXNvdXJjZSwqL1xuLyogdGhpcyBtb2R1bGUgbXVzdCBiZSBjb25zaWRlcmVkIGEgcmVzb3VyY2UgbW9kdWxlLiovXG5cbi8qIFRoZSBhc3NlcnRpb25zIHJlLWV4cG9ydGVkIGhlcmUgYXJlIGRlZmluZWQgaW4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL2Fzc2VydC5qcyovXG5cbmNvbnN0IGdsb2JhbEFzc2VydD1nbG9iYWxUaGlzLmFzc2VydDtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAZW5kby9lcnJvcnMsIG1pc3NpbmcgZ2xvYmFsVGhpcy5hc3NlcnQsIGltcG9ydCAnc2VzJyBiZWZvcmUgJ0BlbmRvL2Vycm9ycydgKTtcblxuIH1cblxuY29uc3QgbWlzc2luZz0vKiogQHR5cGUge2NvbnN0fSAqL1tcbid0eXBlb2YnLFxuJ2Vycm9yJyxcbidmYWlsJyxcbidlcXVhbCcsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyB0aGF0Ki9cbi8qIHByZWRhdGVzIGFkZGl0aW9uIG9mIHRoZSAnYmFyZScgbWV0aG9kLCBzbyB3ZSBtdXN0IHRvbGVyYXRlIGl0cyBhYnNlbmNlIGFuZCBmYWxsKi9cbi8qIGJhY2sgdG8gcXVvdGUgYmVoYXZpb3IgaW4gdGhhdCBlbnZpcm9ubWVudCAoc2VlIGJlbG93KS4qL1xuLyogJ2JhcmUnLCovXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBlbmRvL2Vycm9ycywgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCBtZXRob2RzICR7bWlzc2luZy5qb2luKFxuJywgJylcbiB9YCk7XG5cbiB9XG5cbi8qIFRoZSBnbG9iYWwgYXNzZXJ0IG1peGVkIGFzc2VydGlvbnMgYW5kIHV0aWxpdHkgZnVuY3Rpb25zLiovXG4vKiBUaGlzIG1vZHVsZSBzcGxpdHMgdGhlbSBhcGFydCovXG4vKiBhbmQgYWxzbyB1cGRhdGVzIHRoZSBuYW1lcyBvZiB0aGUgdXRpbGl0eSBmdW5jdGlvbnMuKi9cbmNvbnN0e1xuYmFyZSxcbmRldGFpbHM6cmVkYWN0ZWQsXG5lcnJvcjptYWtlRXJyb3IsXG5GYWlsOnRocm93UmVkYWN0ZWQsXG5tYWtlQXNzZXJ0Ol9vbWl0dGVkTWFrZUFzc2VydCxcbm5vdGUsXG5xdW90ZSxcbi4uLmFzc2VydGlvbnN9PVxuZ2xvYmFsQXNzZXJ0O1xuLyoqIEB0eXBlIHtJTVBPUlQoXCJzZXNcIikuQXNzZXJ0aW9uRnVuY3Rpb25zIH0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgbWlzc2luZyBwcm9wZXJ0aWVzIGFzc2lnbmVkIG5leHQqLyRozY9fb25jZS5yZWRhY3RlZChyZWRhY3RlZCk7JGjNj19vbmNlLm1ha2VFcnJvcihtYWtlRXJyb3IpOyRozY9fb25jZS50aHJvd1JlZGFjdGVkKHRocm93UmVkYWN0ZWQpOyRozY9fb25jZS5ub3RlKG5vdGUpOyRozY9fb25jZS5xdW90ZShxdW90ZSk7XG5jb25zdCBhc3NlcnQ9KHZhbHVlLG9wdERldGFpbHMsZXJyQ29udHJ1Y3RvcixvcHRpb25zKT0+XG5nbG9iYWxBc3NlcnQodmFsdWUsb3B0RGV0YWlscyxlcnJDb250cnVjdG9yLG9wdGlvbnMpOyRozY9fb25jZS5hc3NlcnQoYXNzZXJ0KTtcbk9iamVjdC5hc3NpZ24oYXNzZXJ0LGFzc2VydGlvbnMpO1xuXG4vKiBBcyBvZiAyMDI0LTAyLCB0aGUgQWdvcmljIGNoYWluJ3MgYm9vdHN0cmFwIHZhdCBydW5zIHdpdGggYSB2ZXJzaW9uIG9mIFNFUyovXG4vKiB0aGF0IHByZWRhdGVzIHRoZSBhZGRpdGlvbiBvZiB0aGUgJ2JhcmUnIG1ldGhvZCwgc28gd2UgbXVzdCBmYWxsIGJhY2sgdG8qL1xuLyogcXVvdGUgYmVoYXZpb3IgZm9yIHRoYXQgZW52aXJvbm1lbnQuKi9cbmNvbnN0IGJhcmVPclF1b3RlPWJhcmV8fHF1b3RlO1xuXG4vKiBYWFggbW9kdWxlIGV4cG9ydHMgZmFpbCBpZiB0aGVzZSBhcmVuJ3QgaW4gc2NvcGUqL1xuLyoqIEBpbXBvcnQge0Fzc2VydE1ha2VFcnJvck9wdGlvbnMsIERldGFpbHMsIEdlbmVyaWNFcnJvckNvbnN0cnVjdG9yfSBmcm9tICdzZXMnICovJGjNj19vbmNlLmJhcmVPclF1b3RlKGJhcmVPclF1b3RlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlZGFjdGVkIjpbInJlZGFjdGVkIl0sIlgiOlsicmVkYWN0ZWQiXSwibWFrZUVycm9yIjpbIm1ha2VFcnJvciJdLCJ0aHJvd1JlZGFjdGVkIjpbInRocm93UmVkYWN0ZWQiXSwiRmFpbCI6WyJ0aHJvd1JlZGFjdGVkIl0sIm5vdGUiOlsibm90ZSJdLCJhbm5vdGF0ZUVycm9yIjpbIm5vdGUiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJhc3NlcnQiOlsiYXNzZXJ0Il0sImJhcmUiOlsiYmFyZU9yUXVvdGUiXSwiYiI6WyJiYXJlT3JRdW90ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB+nafgUToAAFE6AAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL0UuanN7ImltcG9ydHMiOlsiLi90cmFjay10dXJucy5qcyIsIi4vbWVzc2FnZS1icmVha3BvaW50cy5qcyJdLCJleHBvcnRzIjpbImRlZmF1bHQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgdHJhY2tUdXJucyxtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXI7JGjNj19pbXBvcnRzKFtbXCIuL3RyYWNrLXR1cm5zLmpzXCIsIFtbXCJ0cmFja1R1cm5zXCIsIFskaM2PX2EgPT4gKHRyYWNrVHVybnMgPSAkaM2PX2EpXV1dXSxbXCIuL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW1tcIm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlclwiLCBbJGjNj19hID0+IChtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWwsZXJyb3I6bWFrZUVycm9yfT1hc3NlcnQ7XG5jb25zdHthc3NpZ24sZnJlZXplfT1PYmplY3Q7XG5cbi8qKlxuICogQGltcG9ydCB7IEhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3IgfSBmcm9tICcuL3R5cGVzLmpzJztcbiAqL1xuXG5jb25zdCBvblNlbmQ9bWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyKCdFTkRPX1NFTkRfQlJFQUtQT0lOVFMnKTtcblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qIEUgUHJveHkgaGFuZGxlcnMgcHJldGVuZCB0aGF0IGFueSBwcm9wZXJ0eSBleGlzdHMgb24gdGhlIHRhcmdldCBhbmQgcmV0dXJucyovXG4vKiBhIGZ1bmN0aW9uIGZvciB0aGVpciB2YWx1ZS4gV2hpbGUgdGhpcyBmdW5jdGlvbiBpcyBcImJvdW5kXCIgYnkgY29udGV4dCwgaXQgaXMqL1xuLyogbWVhbnQgdG8gYmUgY2FsbGVkIGFzIGEgbWV0aG9kLiBGb3IgdGhhdCByZWFzb24sIHRoZSByZXR1cm5lZCBmdW5jdGlvbiovXG4vKiBpbmNsdWRlcyBhIGNoZWNrIHRoYXQgdGhlIGB0aGlzYCBhcmd1bWVudCBjb3JyZXNwb25kcyB0byB0aGUgaW5pdGlhbCovXG4vKiByZWNlaXZlciB3aGVuIHRoZSBmdW5jdGlvbiB3YXMgcmV0cmlldmVkLiovXG4vKiBFIFByb3h5IGhhbmRsZXJzIGFsc28gZm9yd2FyZCBkaXJlY3QgY2FsbHMgdG8gdGhlIHRhcmdldCBpbiBjYXNlIHRoZSByZW1vdGUqL1xuLyogaXMgYSBmdW5jdGlvbiBpbnN0ZWFkIG9mIGFuIG9iamVjdC4gTm8gc3VjaCByZWNlaXZlciBjaGVja3MgYXJlIG5lY2Vzc2FyeSBpbiovXG4vKiB0aGF0IGNhc2UuKi9cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHthbnl9IHJlY2lwaWVudCBBbnkgdmFsdWUgcGFzc2VkIHRvIEUoeClcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXI8dW5rbm93bj59IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFUHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IFByb21pc2U8dW5rbm93bj59ICovXG5bcHJvcGVydHlLZXldKC4uLmFyZ3Mpe1xuaWYodGhpcyE9PXJlY2VpdmVyKXtcbi8qIFJlamVjdCB0aGUgYXN5bmMgZnVuY3Rpb24gY2FsbCovXG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVqZWN0KFxubWFrZUVycm9yKFxuWCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3EocHJvcGVydHlLZXkpfVwiIG1ldGhvZCBvZiBFKCR7cShcbnJlY2lwaWVudClcbiB9KWApKTtcblxuXG4gfVxuXG5pZihvblNlbmQmJm9uU2VuZC5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxwcm9wZXJ0eUtleSkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBtZXRob2QtY2FsbCovXG4vKiBtZXNzYWdlLCovXG4vKiBzbyB0aGF0IHlvdSBjYW4gd2FsayBiYWNrIG9uIHRoZSBzdGFjayB0byBzZWUgaG93IHdlIGNhbWUgdG8qL1xuLyogbWFrZSB0aGlzIGV2ZW50dWFsLXNlbmQqL1xuIH1cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZChyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucHJvcGVydHlLZXldKTtcblxuIH0sXG5hcHBseTooX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSk9PntcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIExPT0sgVVAgVEhFIFNUQUNLKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIGV2ZW50dWFsLXNlbmQgb2YgYSBmdW5jdGlvbi1jYWxsIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ0FycmF5KTtcbiB9LFxuaGFzOihfdGFyZ2V0LF9wKT0+e1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUuc2VuZE9ubHkoeClcbiAqIEl0IGlzIGEgdmFyaWFudCBvbiB0aGUgRSh4KSBQcm94eSBoYW5kbGVyLlxuICpcbiAqIEBwYXJhbSB7YW55fSByZWNpcGllbnQgQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge0hhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7UHJveHlIYW5kbGVyPHVua25vd24+fSB0aGUgUHJveHkgaGFuZGxlclxuICovXG5jb25zdCBtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyPShyZWNpcGllbnQsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHByb3BlcnR5S2V5LHJlY2VpdmVyKT0+e1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuLyoqIEB0eXBlIHsoLi4uYXJnczogYW55W10pID0+IHVuZGVmaW5lZH0gKi9cbltwcm9wZXJ0eUtleV0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShcbnByb3BlcnR5S2V5KVxuIH1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EocmVjaXBpZW50KX0pYDtcbmlmKG9uU2VuZCYmb25TZW5kLnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHByb3BlcnR5S2V5KSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIG1ldGhvZC1jYWxsKi9cbi8qIG1lc3NhZ2UsKi9cbi8qIHNvIHRoYXQgeW91IGNhbiB3YWxrIGJhY2sgb24gdGhlIHN0YWNrIHRvIHNlZSBob3cgd2UgY2FtZSB0byovXG4vKiBtYWtlIHRoaXMgZXZlbnR1YWwtc2VuZCovXG4gfVxuSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2RTZW5kT25seShyZWNpcGllbnQscHJvcGVydHlLZXksYXJncyk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDMxOSovfVtcbnByb3BlcnR5S2V5XSk7XG5cbiB9LFxuYXBwbHk6KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKT0+e1xuaWYob25TZW5kJiZvblNlbmQuc2hvdWxkQnJlYWtwb2ludChyZWNpcGllbnQsdW5kZWZpbmVkKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogTE9PSyBVUCBUSEUgU1RBQ0sqL1xuLyogU3RvcHBlZCBhdCBhIGJyZWFrcG9pbnQgb24gZXZlbnR1YWwtc2VuZCBvZiBhIGZ1bmN0aW9uLWNhbGwgbWVzc2FnZSwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHdhbGsgYmFjayBvbiB0aGUgc3RhY2sgdG8gc2VlIGhvdyB3ZSBjYW1lIHRvKi9cbi8qIG1ha2UgdGhpcyBldmVudHVhbC1zZW5kKi9cbiB9XG5IYW5kbGVkUHJvbWlzZS5hcHBseUZ1bmN0aW9uU2VuZE9ubHkocmVjaXBpZW50LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXM6KF90YXJnZXQsX3ApPT57XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLmdldCh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHthbnl9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLmdldCh4KVxuICogQHBhcmFtIHtIYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcjx1bmtub3duPn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuY29uc3QgbWFrZUVHZXRQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzOihfdGFyZ2V0LF9wcm9wKT0+dHJ1ZSxcbmdldDooX3RhcmdldCxwcm9wKT0+SGFuZGxlZFByb21pc2UuZ2V0KHgscHJvcCl9KTtcblxuXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBmdW5jVGFyZ2V0PWZyZWV6ZSgoKT0+eyB9KTtcblxuLyoqXG4vKipcbiAqIGBmcmVlemVgIGJ1dCBub3QgYGhhcmRlbmAgdGhlIHByb3h5IHRhcmdldCBzbyBpdCByZW1haW5zIHRyYXBwaW5nLlxuICogVGh1cywgaXQgc2hvdWxkIG5vdCBiZSBzaGFyZWQgb3V0c2lkZSB0aGlzIG1vZHVsZS5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9ibG9iL21hc3Rlci9wYWNrYWdlcy9zZXMvZG9jcy9wcmVwYXJpbmctZm9yLXN0YWJpbGl6ZS5tZFxuICovXG5jb25zdCBvYmpUYXJnZXQ9ZnJlZXplKHtfX3Byb3RvX186bnVsbH0pO1xuXG4vKipcbiAqIEBwYXJhbSB7SGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqL1xuY29uc3QgbWFrZUU9KEhhbmRsZWRQcm9taXNlKT0+e1xucmV0dXJuIGhhcmRlbihcbmFzc2lnbihcbi8qKlxuICogRSh4KSByZXR1cm5zIGEgcHJveHkgb24gd2hpY2ggeW91IGNhbiBjYWxsIGFyYml0cmFyeSBtZXRob2RzLiBFYWNoIG9mIHRoZXNlXG4gKiBtZXRob2QgY2FsbHMgcmV0dXJucyBhIHByb21pc2UuIFRoZSBtZXRob2Qgd2lsbCBiZSBpbnZva2VkIG9uIHdoYXRldmVyXG4gKiAneCcgZGVzaWduYXRlcyAob3IgcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgbWV0aG9kL2Z1bmN0aW9uIGNhbGxcbiAqIEByZXR1cm5zIHtFQ2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqL1xuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG4oeCk9Pm5ldyBQcm94eShmdW5jVGFyZ2V0LG1ha2VFUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcbntcbi8qKlxuICogRS5nZXQoeCkgcmV0dXJucyBhIHByb3h5IG9uIHdoaWNoIHlvdSBjYW4gZ2V0IGFyYml0cmFyeSBwcm9wZXJ0aWVzLlxuICogRWFjaCBvZiB0aGVzZSBwcm9wZXJ0aWVzIHJldHVybnMgYSBwcm9taXNlIGZvciB0aGUgcHJvcGVydHkuICBUaGUgcHJvbWlzZVxuICogdmFsdWUgd2lsbCBiZSB0aGUgcHJvcGVydHkgZmV0Y2hlZCBmcm9tIHdoYXRldmVyICd4JyBkZXNpZ25hdGVzIChvclxuICogcmVzb2x2ZXMgdG8pIGluIGEgZnV0dXJlIHR1cm4sIG5vdCB0aGlzIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgcHJvcGVydHkgZ2V0XG4gKiBAcmV0dXJucyB7RUdldHRlcnM8TG9jYWxSZWNvcmQ8VD4+fSBwcm9wZXJ0eSBnZXQgcHJveHlcbiAqIEByZWFkb25seVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCB0eXBlZGVmKi9cbmdldDooeCk9Pm5ldyBQcm94eShvYmpUYXJnZXQsbWFrZUVHZXRQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSkpLFxuXG4vKipcbiAqIEUucmVzb2x2ZSh4KSBjb252ZXJ0cyB4IHRvIGEgaGFuZGxlZCBwcm9taXNlLiBJdCBpc1xuICogc2hvcnRoYW5kIGZvciBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gaGFuZGxlZCBwcm9taXNlIGZvciB4XG4gKiBAcmVhZG9ubHlcbiAqL1xucmVzb2x2ZTpIYW5kbGVkUHJvbWlzZS5yZXNvbHZlLFxuXG4vKipcbiAqIEUuc2VuZE9ubHkgcmV0dXJucyBhIHByb3h5IHNpbWlsYXIgdG8gRSwgYnV0IGZvciB3aGljaCB0aGUgcmVzdWx0c1xuICogYXJlIGlnbm9yZWQgKHVuZGVmaW5lZCBpcyByZXR1cm5lZCkuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0geCB0YXJnZXQgZm9yIG1ldGhvZC9mdW5jdGlvbiBjYWxsXG4gKiBAcmV0dXJucyB7RVNlbmRPbmx5Q2FsbGFibGVPck1ldGhvZHM8UmVtb3RlRnVuY3Rpb25zPFQ+Pn0gbWV0aG9kL2Z1bmN0aW9uIGNhbGwgcHJveHlcbiAqIEByZWFkb25seVxuICovXG5zZW5kT25seTooeCk9PlxuLyogQHRzLWV4cGVjdC1lcnJvciBYWFggdHlwZWRlZiovXG5uZXcgUHJveHkoZnVuY1RhcmdldCxtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSxcblxuLyoqXG4gKiBFLndoZW4oeCwgcmVzLCByZWopIGlzIGVxdWl2YWxlbnQgdG9cbiAqIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihyZXMsIHJlailcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtVID0gVF1cbiAqIEBwYXJhbSB7VHxQcm9taXNlTGlrZTxUPn0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gRVJlZjxVPn0gW29uZnVsZmlsbGVkXVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IEVSZWY8VT59IFtvbnJlamVjdGVkXVxuICogQHJldHVybnMge1Byb21pc2U8VT59XG4gKiBAcmVhZG9ubHlcbiAqL1xud2hlbjooeCxvbmZ1bGZpbGxlZCxvbnJlamVjdGVkKT0+XG5IYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4oXG4uLi50cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSkpfSkpO1xuXG5cblxuXG4gfTtcblxuY29uc3R7ZGVmYXVsdDokY82PX2RlZmF1bHR9PXtkZWZhdWx0Om1ha2VFfTtcblxuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPG1ha2VFPn0gRVByb3h5ICovXG5cbi8qKlxuICogRGVjbGFyZSBhbiBvYmplY3QgdGhhdCBpcyBwb3RlbnRpYWxseSBhIGZhciByZWZlcmVuY2Ugb2YgdHlwZSBQcmltYXJ5IHdob3NlXG4gKiBhdXhpbGxpYXJ5IGRhdGEgaGFzIHR5cGUgTG9jYWwuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yIGNvbnN1bWVycyBvZlxuICogRmFyIG9iamVjdHMgaW4gYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHRoZSBvbmx5IGNyZWF0b3JzIG9mIEZhciBvYmplY3RzXG4gKiBhcmUgZGlzdHJpYnV0ZWQgb2JqZWN0IGNyZWF0b3IgY29tcG9uZW50cyBsaWtlIHRoZSBgRmFyYCBvciBgUmVtb3RhYmxlYFxuICogZnVuY3Rpb25zLlxuICpcbiAqIEB0ZW1wbGF0ZSBQcmltYXJ5IFRoZSB0eXBlIG9mIHRoZSBwcmltYXJ5IHJlZmVyZW5jZS5cbiAqIEB0ZW1wbGF0ZSBbTG9jYWw9RGF0YU9ubHk8UHJpbWFyeT5dIFRoZSBsb2NhbCBwcm9wZXJ0aWVzIG9mIHRoZSBvYmplY3QuXG4gKiBAdHlwZWRlZiB7RVJlZjxMb2NhbCAmIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPExvY2FsLCBQcmltYXJ5Pj59IEZhclJlZlxuICovXG5cbi8qKlxuICogYERhdGFPbmx5PFQ+YCBtZWFucyB0byByZXR1cm4gYSByZWNvcmQgdHlwZSBgVDJgIGNvbnNpc3Rpbmcgb25seSBvZlxuICogcHJvcGVydGllcyB0aGF0IGFyZSAqbm90KiBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgdG8gYmUgZmlsdGVyZWQuXG4gKiBAdHlwZWRlZiB7T21pdDxULCBGaWx0ZXJlZEtleXM8VCwgSU1QT1JUKCcuL3R5cGVzLmpzJykuQ2FsbGFibGU+Pn0gRGF0YU9ubHlcbiAqL1xuXG4vKipcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMzEzOTR9XG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1Byb21pc2VMaWtlPFQ+IHwgVH0gRVJlZlxuICogRGVjbGFyZSB0aGF0IGBUYCBtYXkgb3IgbWF5IG5vdCBiZSBhIFByb21pc2UuICBUaGlzIHNob3VsZCBiZSB1c2VkIG9ubHkgZm9yXG4gKiBjb25zdW1lcnMgb2YgYXJndW1lbnRzIGFuZCBkZWNsYXJhdGlvbnM7IHJldHVybiB2YWx1ZXMgc2hvdWxkIHNwZWNpZmljYWxseSBiZVxuICogYFByb21pc2U8VD5gIG9yIGBUYCBpdHNlbGYuXG4gKi9cblxuLyoqXG4gKiBUaGUgYXdhaXRlZCByZXR1cm4gdHlwZSBvZiBhIGZ1bmN0aW9uLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgKC4uLmFyZ3M6IGFueVtdKSA9PiBpbmZlciBSID8gQXdhaXRlZDxSPiA6IG5ldmVyfSBFUmV0dXJuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBSZXR1cm5UeXBlPFQ+IGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT4gICAgICAgICAgICAgICAgICAgICAgIC8vIGlmIGZ1bmN0aW9uIHJldHVybnMgYSBwcm9taXNlXG4gKiAgICAgPyBUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIHRoZSBmdW5jdGlvblxuICogICAgIDogKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8RVJldHVybjxUPj4gIC8vIG1ha2UgaXQgcmV0dXJuIGEgcHJvbWlzZVxuICogKX0gRUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRUNhbGxhYmxlPFRbUF0+XG4gKiAgICAgOiBuZXZlcjtcbiAqIH19IEVNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPlxuICogICAgID8gVFtQXVxuICogICAgIDogUHJvbWlzZTxBd2FpdGVkPFRbUF0+PjtcbiAqIH19IEVHZXR0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8dm9pZD59IEVTZW5kT25seUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VFtQXT5cbiAqICAgICA6IG5ldmVyO1xuICogfX0gRVNlbmRPbmx5TWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VD4gJiBFU2VuZE9ubHlNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogICAgIDogRVNlbmRPbmx5TWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICl9IEVTZW5kT25seUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyBFQ2FsbGFibGU8VD4gJiBFTWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICAgICA6IEVNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogKX0gRUNhbGxhYmxlT3JNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBSZXR1cm4gYSB1bmlvbiBvZiBwcm9wZXJ0eSBuYW1lcy9zeW1ib2xzL251bWJlcnMgUCBmb3Igd2hpY2ggdGhlIHJlY29yZCBlbGVtZW50IFRbUF0ncyB0eXBlIGV4dGVuZHMgVS5cbiAqXG4gKiBHaXZlbiBjb25zdCB4ID0geyBhOiAxMjMsIGI6ICdoZWxsbycsIGM6IDQyLCA0OTogKCkgPT4ge30sIDUzOiA2NyB9LFxuICpcbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgbnVtYmVyPiBpcyB0aGUgdHlwZSAnYScgfCAnYycgfCA1My5cbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgc3RyaW5nPiBpcyB0aGUgdHlwZSAnYicuXG4gKiBGaWx0ZXJlZEtleXM8dHlwZW9mIHgsIDQyIHwgNjc+IGlzIHRoZSB0eXBlICdjJyB8IDUzLlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBib29sZWFuPiBpcyB0aGUgdHlwZSBuZXZlci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFVcbiAqIEB0eXBlZGVmIHt7IFtQIGluIGtleW9mIFRdOiBUW1BdIGV4dGVuZHMgVSA/IFAgOiBuZXZlcjsgfVtrZXlvZiBUXX0gRmlsdGVyZWRLZXlzXG4gKi9cblxuLyoqXG4gKiBgUGlja0NhbGxhYmxlPFQ+YCBtZWFucyB0byByZXR1cm4gYSBzaW5nbGUgcm9vdCBjYWxsYWJsZSBvciBhIHJlY29yZCB0eXBlXG4gKiBjb25zaXN0aW5nIG9ubHkgb2YgcHJvcGVydGllcyB0aGF0IGFyZSBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFJldHVyblR5cGU8VD4gICAgICAgICAgICAgICAgICAgICAvLyBhIHJvb3QgY2FsbGFibGUsIG5vIG1ldGhvZHNcbiAqICAgICA6IFBpY2s8VCwgRmlsdGVyZWRLZXlzPFQsIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPj4gICAgICAgICAgLy8gYW55IGNhbGxhYmxlIG1ldGhvZHNcbiAqICl9IFBpY2tDYWxsYWJsZVxuICovXG5cbi8qKlxuICogYFJlbW90ZUZ1bmN0aW9uczxUPmAgbWVhbnMgdG8gcmV0dXJuIHRoZSBmdW5jdGlvbnMgYW5kIHByb3BlcnRpZXMgdGhhdCBhcmUgcmVtb3RlbHkgY2FsbGFibGUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPiAgICAgLy8gaWYgYSBnaXZlbiBUIGlzIHNvbWUgcmVtb3RlIGludGVyZmFjZSBSXG4gKiAgICAgPyBQaWNrQ2FsbGFibGU8Uj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gdGhlIGNhbGxhYmxlIHByb3BlcnRpZXMgb2YgUlxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+IC8vIG90aGVyd2lzZSwgaWYgdGhlIGZpbmFsIHJlc29sdXRpb24gb2YgVCBpcyBzb21lIHJlbW90ZSBpbnRlcmZhY2UgUlxuICogICAgID8gUGlja0NhbGxhYmxlPFI+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIHRoZW4gcmV0dXJuIHRoZSBjYWxsYWJsZSBwcm9wZXJ0aWVzIG9mIFJcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UsIGlmIFQgaXMgYSBwcm9taXNlXG4gKiAgICAgPyBBd2FpdGVkPFQ+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gcmVzb2x2ZWQgdmFsdWUgVFxuICogICAgIDogVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG90aGVyd2lzZSwgcmV0dXJuIFRcbiAqICl9IFJlbW90ZUZ1bmN0aW9uc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBJTVBPUlQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVCcmFuZDxpbmZlciBMLCBpbmZlciBSPlxuICogICAgID8gTFxuICogICAgIDogQXdhaXRlZDxUPiBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+XG4gKiAgICAgPyBMXG4gKiAgICAgOiBUIGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT5cbiAqICAgICA/IEF3YWl0ZWQ8VD5cbiAqICAgICA6IFRcbiAqICl9IExvY2FsUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1IgPSB1bmtub3duXVxuICogQHR5cGVkZWYge3tcbiAqICAgcHJvbWlzZTogUHJvbWlzZTxSPjtcbiAqICAgc2V0dGxlcjogSU1QT1JUKCcuL3R5cGVzLmpzJykuU2V0dGxlcjxSPjtcbiAqIH19IEVQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBEZWNsYXJlIGEgbmVhciBvYmplY3QgdGhhdCBtdXN0IG9ubHkgYmUgaW52b2tlZCB3aXRoIEUsIGV2ZW4gbG9jYWxseS4gIEl0XG4gKiBzdXBwb3J0cyB0aGUgYFRgIGludGVyZmFjZSBidXQgYWRkaXRpb25hbGx5IHBlcm1pdHMgYFRgJ3MgbWV0aG9kcyB0byByZXR1cm5cbiAqIGBQcm9taXNlTGlrZWBzIGV2ZW4gaWYgYFRgIGRlY2xhcmVzIHRoZW0gYXMgb25seSBzeW5jaHJvbm91cy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VD4+Pj5cbiAqICAgICA6IFQgZXh0ZW5kcyBSZWNvcmQ8UHJvcGVydHlLZXksIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlPlxuICogICAgID8ge1xuICogICAgICAgICBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIElNUE9SVCgnLi90eXBlcy5qcycpLkNhbGxhYmxlXG4gKiAgICAgICAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUW0tdPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VFtLXT4+Pj5cbiAqICAgICAgICAgICA6IFRbS107XG4gKiAgICAgICB9XG4gKiAgICAgOiBUXG4gKiApfSBFT25seVxuICovJGjNj19vbmNlLmRlZmF1bHQoJGPNj19kZWZhdWx0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAEusOTSgEAAEoBAAApAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2V4cG9ydHMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG2wnmyYEQAAmBEAACcAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbG9jYWwuanN7ImltcG9ydHMiOlsiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOlsiZ2V0TWV0aG9kTmFtZXMiLCJsb2NhbEFwcGx5RnVuY3Rpb24iLCJsb2NhbEFwcGx5TWV0aG9kIiwibG9jYWxHZXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyOyRozY9faW1wb3J0cyhbW1wiLi9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzXCIsIFtbXCJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcIiwgWyRozY9fYSA9PiAobWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyID0gJGjNj19hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzLGdldFByb3RvdHlwZU9mLGZyZWV6ZX09T2JqZWN0O1xuY29uc3R7YXBwbHksb3duS2V5c309UmVmbGVjdDtcblxuY29uc3QgbnR5cGVvZj0oc3BlY2ltZW4pPT5zcGVjaW1lbj09PW51bGw/J251bGwnOnR5cGVvZiBzcGVjaW1lbjtcblxuY29uc3Qgb25EZWxpdmVyeT1tYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIoJ0VORE9fREVMSVZFUllfQlJFQUtQT0lOVFMnKTtcblxuLyoqXG4gKiBUT0RPIENvbnNvbGlkYXRlIHdpdGggYGlzT2JqZWN0YCB0aGF0J3MgY3VycmVudGx5IGluIGBAZW5kby9tYXJzaGFsYFxuICpcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7XG5cbi8qKlxuICogUHJpb3JpdGl6ZSBzeW1ib2xzIGFzIGVhcmxpZXIgdGhhbiBzdHJpbmdzLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0gYVxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBiXG4gKiBAcmV0dXJucyB7LTEgfCAwIHwgMX1cbiAqL1xuY29uc3QgY29tcGFyZVN0cmluZ2lmaWVkPShhLGIpPT57XG5pZih0eXBlb2YgYT09PXR5cGVvZiBiKXtcbmNvbnN0IGxlZnQ9U3RyaW5nKGEpO1xuY29uc3QgcmlnaHQ9U3RyaW5nKGIpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLW5lc3RlZC10ZXJuYXJ5Ki9cbnJldHVybiBsZWZ0PHJpZ2h0Py0xOmxlZnQ+cmlnaHQ/MTowO1xuIH1cbmlmKHR5cGVvZiBhPT09J3N5bWJvbCcpe1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N0cmluZycpO1xucmV0dXJuLTE7XG4gfVxuYXNzZXJ0KHR5cGVvZiBhPT09J3N0cmluZycpO1xuYXNzZXJ0KHR5cGVvZiBiPT09J3N5bWJvbCcpO1xucmV0dXJuIDE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGRlc2NzKSl7XG4vKiBJbiBjYXNlIGEgbWV0aG9kIGlzIG92ZXJyaWRkZW4gYnkgYSBub24tbWV0aG9kLCovXG4vKiB0ZXN0IGB2YWxbbmFtZV1gIHJhdGhlciB0aGFuIGBsYXllcltuYW1lXWAqL1xuaWYodHlwZW9mIHZhbFtuYW1lXT09PSdmdW5jdGlvbicpe1xubmFtZXMuYWRkKG5hbWUpO1xuIH1cbiB9XG5pZighaXNPYmplY3QodmFsKSl7XG5icmVhaztcbiB9XG5sYXllcj1nZXRQcm90b3R5cGVPZihsYXllcik7XG4gfVxucmV0dXJuIGhhcmRlbihbLi4ubmFtZXNdLnNvcnQoY29tcGFyZVN0cmluZ2lmaWVkKSk7XG4gfTtcbi8qIFRoZSB0b3AgbGV2ZWwgb2YgdGhlIGV2ZW50dWFsIHNlbmQgbW9kdWxlcyBjYW4gYmUgZXZhbHVhdGVkIGJlZm9yZSovXG4vKiBzZXMgY3JlYXRlcyBgaGFyZGVuYCwgYW5kIHNvIGNhbm5vdCByZWx5IG9uIGBoYXJkZW5gIGF0IHRvcCBsZXZlbC4qLyRozY9fb25jZS5nZXRNZXRob2ROYW1lcyhnZXRNZXRob2ROYW1lcyk7XG5mcmVlemUoZ2V0TWV0aG9kTmFtZXMpO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseUZ1bmN0aW9uPShyZWNpcGllbnQsYXJncyk9PntcbnR5cGVvZiByZWNpcGllbnQ9PT0nZnVuY3Rpb24nfHxcbmFzc2VydC5mYWlsKFxuWCBgQ2Fubm90IGludm9rZSB0YXJnZXQgYXMgYSBmdW5jdGlvbjsgdHlwZW9mIHRhcmdldCBpcyAke3EoXG5udHlwZW9mKHJlY2lwaWVudCkpXG4gfWAsXG5UeXBlRXJyb3IpO1xuXG5pZihvbkRlbGl2ZXJ5JiZvbkRlbGl2ZXJ5LnNob3VsZEJyZWFrcG9pbnQocmVjaXBpZW50LHVuZGVmaW5lZCkpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWRlYnVnZ2VyKi9cbmRlYnVnZ2VyOy8qIFNURVAgSU5UTyBBUFBMWSovXG4vKiBTdG9wcGVkIGF0IGEgYnJlYWtwb2ludCBvbiB0aGlzIGRlbGl2ZXJ5IG9mIGFuIGV2ZW50dWFsIGZ1bmN0aW9uIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIGZ1bmN0aW9uIGNhbGwgYXMgaXQgaGFwcGVucy4gT3Igc3RlcCAqb3ZlciogdG8gc2VlIHdoYXQgaGFwcGVucyovXG4vKiBhZnRlciB0aGUgZnVuY3Rpb24gY2FsbCByZXR1cm5zLiovXG4gfVxuY29uc3QgcmVzdWx0PWFwcGx5KHJlY2lwaWVudCx1bmRlZmluZWQsYXJncyk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjNj19vbmNlLmxvY2FsQXBwbHlGdW5jdGlvbihsb2NhbEFwcGx5RnVuY3Rpb24pO1xuXG5jb25zdCAgICAgICAgbG9jYWxBcHBseU1ldGhvZD0ocmVjaXBpZW50LG1ldGhvZE5hbWUsYXJncyk9PntcbmlmKG1ldGhvZE5hbWU9PT11bmRlZmluZWR8fG1ldGhvZE5hbWU9PT1udWxsKXtcbi8qIEJhc2UgY2FzZTsgYm90dG9tIG91dCB0byBhcHBseSBmdW5jdGlvbnMuKi9cbnJldHVybiBsb2NhbEFwcGx5RnVuY3Rpb24ocmVjaXBpZW50LGFyZ3MpO1xuIH1cbmlmKHJlY2lwaWVudD09PXVuZGVmaW5lZHx8cmVjaXBpZW50PT09bnVsbCl7XG5hc3NlcnQuZmFpbChcblggYENhbm5vdCBkZWxpdmVyICR7cShtZXRob2ROYW1lKX0gdG8gdGFyZ2V0OyB0eXBlb2YgdGFyZ2V0IGlzICR7cShcbm50eXBlb2YocmVjaXBpZW50KSlcbiB9YCxcblR5cGVFcnJvcik7XG5cbiB9XG5jb25zdCBmbj1yZWNpcGllbnRbbWV0aG9kTmFtZV07XG5pZihmbj09PXVuZGVmaW5lZCl7XG5hc3NlcnQuZmFpbChcblggYHRhcmdldCBoYXMgbm8gbWV0aG9kICR7cShtZXRob2ROYW1lKX0sIGhhcyAke3EoXG5nZXRNZXRob2ROYW1lcyhyZWNpcGllbnQpKVxuIH1gLFxuVHlwZUVycm9yKTtcblxuIH1cbmNvbnN0IGZ0eXBlPW50eXBlb2YoZm4pO1xudHlwZW9mIGZuPT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBpbnZva2VkIG1ldGhvZCAke3EobWV0aG9kTmFtZSl9IGlzIG5vdCBhIGZ1bmN0aW9uOyBpdCBpcyBhICR7cShcbmZ0eXBlKVxuIH1gO1xuaWYob25EZWxpdmVyeSYmb25EZWxpdmVyeS5zaG91bGRCcmVha3BvaW50KHJlY2lwaWVudCxtZXRob2ROYW1lKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZGVidWdnZXIqL1xuZGVidWdnZXI7LyogU1RFUCBJTlRPIEFQUExZKi9cbi8qIFN0b3BwZWQgYXQgYSBicmVha3BvaW50IG9uIHRoaXMgZGVsaXZlcnkgb2YgYW4gZXZlbnR1YWwgbWV0aG9kIGNhbGwqL1xuLyogc28gdGhhdCB5b3UgY2FuIHN0ZXAgKmludG8qIHRoZSBmb2xsb3dpbmcgYGFwcGx5YCBpbiBvcmRlciB0byBzZWUgdGhlKi9cbi8qIG1ldGhvZCBjYWxsIGFzIGl0IGhhcHBlbnMuIE9yIHN0ZXAgKm92ZXIqIHRvIHNlZSB3aGF0IGhhcHBlbnMqL1xuLyogYWZ0ZXIgdGhlIG1ldGhvZCBjYWxsIHJldHVybnMuKi9cbiB9XG5jb25zdCByZXN1bHQ9YXBwbHkoZm4scmVjaXBpZW50LGFyZ3MpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRozY9fb25jZS5sb2NhbEFwcGx5TWV0aG9kKGxvY2FsQXBwbHlNZXRob2QpO1xuXG5jb25zdCAgICAgICAgbG9jYWxHZXQ9KHQsa2V5KT0+dFtrZXldOyRozY9fb25jZS5sb2NhbEdldChsb2NhbEdldCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJsb2NhbEFwcGx5RnVuY3Rpb24iOlsibG9jYWxBcHBseUZ1bmN0aW9uIl0sImxvY2FsQXBwbHlNZXRob2QiOlsibG9jYWxBcHBseU1ldGhvZCJdLCJsb2NhbEdldCI6WyJsb2NhbEdldCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABt8TAWoRYAAKEWAAA1AAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgZ2V0RW52aXJvbm1lbnRPcHRpb247JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuY29uc3R7aGFzT3duLGZyZWV6ZSxlbnRyaWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZyB8ICcqJ30gTWF0Y2hTdHJpbmdUYWdcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IHJlY2lwaWVudC4gT3RoZXJ3aXNlLCB0aGUgc3RyaW5nIGlzXG4gKiAgIG1hdGNoZWQgYWdhaW5zdCB0aGUgdmFsdWUgb2YgYSByZWNpcGllbnQncyBgQEB0b1N0cmluZ1RhZ2BcbiAqICAgYWZ0ZXIgc3RyaXBwaW5nIG91dCBhbnkgbGVhZGluZyBgJ0FsbGVnZWQ6ICdgIG9yIGAnRGVidWdOYW1lOiAnYFxuICogICBwcmVmaXguIEZvciBvYmplY3RzIGRlZmluZWQgd2l0aCBgRmFyYCB0aGlzIGlzIHRoZSBmaXJzdCBhcmd1bWVudCxcbiAqICAga25vd24gYXMgdGhlIGBmYXJOYW1lYC4gRm9yIGV4b3MsIHRoaXMgaXMgdGhlIHRhZy5cbiAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgJyonfSBNYXRjaE1ldGhvZE5hbWVcbiAqICAgQSBzdGFyIGAnKidgIG1hdGNoZXMgYW55IG1ldGhvZCBuYW1lLiBPdGhlcndpc2UsIHRoZSBzdHJpbmcgaXNcbiAqICAgbWF0Y2hlZCBhZ2FpbnN0IHRoZSBtZXRob2QgbmFtZS4gQ3VycmVudGx5LCB0aGlzIGlzIG9ubHkgYW4gZXhhY3QgbWF0Y2guXG4gKiAgIEhvd2V2ZXIsIGJld2FyZSB0aGF0IHdlIG1heSBpbnRyb2R1Y2UgYSBzdHJpbmcgc3ludGF4IGZvclxuICogICBzeW1ib2wgbWV0aG9kIG5hbWVzLlxuICovXG4vKipcbiAqIEB0eXBlZGVmIHtudW1iZXIgfCAnKid9IE1hdGNoQ291bnRkb3duXG4gKiAgIEEgc3RhciBgJyonYCB3aWxsIGFsd2F5cyBicmVha3BvaW50LiBPdGhlcndpc2UsIHRoZSBzdHJpbmdcbiAqICAgbXVzdCBiZSBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyLiBPbmNlIHRoYXQgaXMgemVybywgYWx3YXlzIGJyZWFrcG9pbnQuXG4gKiAgIE90aGVyd2lzZSBkZWNyZW1lbnQgYnkgb25lIGVhY2ggdGltZSBpdCBtYXRjaGVzIHVudGlsIGl0IHJlYWNoZXMgemVyby5cbiAqICAgSW4gb3RoZXIgd29yZHMsIHRoZSBjb3VudGRvd24gcmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mXG4gKiAgIGJyZWFrcG9pbnQgb2NjdXJyZW5jZXMgdG8gc2tpcCBiZWZvcmUgYWN0dWFsbHkgYnJlYWtwb2ludGluZy5cbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIGV4dGVybmFsIEpTT04gcmVwcmVzZW50YXRpb24sIGluIHdoaWNoXG4gKiAtIHRoZSBvdXRlciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBjbGFzcy1saWtlIHRhZyBvciAnKicsXG4gKiAtIHRoZSBpbm5lciBwcm9wZXJ0eSBuYW1lIGlzIHRoZSBtZXRob2QgbmFtZSBvciAnKicsXG4gKiAtIHRoZSB2YWx1ZSBpcyBhIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyIGNvdW50ZG93biBvciAnKicuXG4gKlxuICogQHR5cGVkZWYge1JlY29yZDxNYXRjaFN0cmluZ1RhZywgUmVjb3JkPE1hdGNoTWV0aG9kTmFtZSwgTWF0Y2hDb3VudGRvd24+Pn0gTWVzc2FnZUJyZWFrcG9pbnRzXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBpbnRlcm5hbCBKU09OIHJlcHJlc2VudGF0aW9uLCBpbiB3aGljaFxuICogLSB0aGUgb3V0ZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgbWV0aG9kIG5hbWUgb3IgJyonLFxuICogLSB0aGUgaW5uZXIgcHJvcGVydHkgbmFtZSBpcyB0aGUgY2xhc3MtbGlrZSB0YWcgb3IgJyonLFxuICogLSB0aGUgdmFsdWUgaXMgYSBub24tbmVnYXRpdmUgaW50ZWdlciBjb3VudGRvd24gb3IgJyonLlxuICpcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8TWF0Y2hNZXRob2ROYW1lLCBSZWNvcmQ8TWF0Y2hTdHJpbmdUYWcsIE1hdGNoQ291bnRkb3duPj59IEJyZWFrcG9pbnRUYWJsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gTWVzc2FnZUJyZWFrcG9pbnRzfSBnZXRCcmVha3BvaW50c1xuICogQHByb3BlcnR5IHsobmV3QnJlYWtwb2ludHM/OiBNZXNzYWdlQnJlYWtwb2ludHMpID0+IHZvaWR9IHNldEJyZWFrcG9pbnRzXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVjaXBpZW50OiBvYmplY3QsXG4gKiAgIG1ldGhvZE5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IHVuZGVmaW5lZFxuICogKSA9PiBib29sZWFufSBzaG91bGRCcmVha3BvaW50XG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gdmFsXG4gKiBAcmV0dXJucyB7dmFsIGlzIFJlY29yZDxzdHJpbmcsIGFueT59XG4gKi9cbmNvbnN0IGlzSlNPTlJlY29yZD0odmFsKT0+XG50eXBlb2YgdmFsPT09J29iamVjdCcmJnZhbCE9PW51bGwmJiFBcnJheS5pc0FycmF5KHZhbCk7XG5cbi8qKlxuICogUmV0dXJuIGB0YWdgIGFmdGVyIHN0cmlwcGluZyBvZmYgYW55IGAnQWxsZWdlZDogJ2Agb3IgYCdEZWJ1Z05hbWU6ICdgXG4gKiBwcmVmaXggaWYgcHJlc2VudC5cbiAqIGBgYGpzXG4gKiBzaW1wbGlmeVRhZygnQWxsZWdlZDogbW9vbGEgaXNzdWVyJykgPT09ICdtb29sYSBpc3N1ZXInXG4gKiBgYGBcbiAqIElmIHRoZXJlIGFyZSBtdWx0aXBsZSBzdWNoIHByZWZpeGVzLCBvbmx5IHRoZSBvdXRlciBvbmUgaXMgcmVtb3ZlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBzaW1wbGlmeVRhZz0odGFnKT0+e1xuZm9yKGNvbnN0IHByZWZpeCBvZlsnQWxsZWdlZDogJywnRGVidWdOYW1lOiAnXSl7XG5pZih0YWcuc3RhcnRzV2l0aChwcmVmaXgpKXtcbnJldHVybiB0YWcuc2xpY2UocHJlZml4Lmxlbmd0aCk7XG4gfVxuIH1cbnJldHVybiB0YWc7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHJldHVybnMge01lc3NhZ2VCcmVha3BvaW50VGVzdGVyIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCAgICAgICAgbWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyPShvcHRpb25OYW1lKT0+e1xubGV0IGJyZWFrcG9pbnRzPUpTT04ucGFyc2UoZ2V0RW52aXJvbm1lbnRPcHRpb24ob3B0aW9uTmFtZSwnbnVsbCcpKTtcblxuaWYoYnJlYWtwb2ludHM9PT1udWxsKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbmxldCBicmVha3BvaW50c1RhYmxlO1xuXG5jb25zdCBnZXRCcmVha3BvaW50cz0oKT0+YnJlYWtwb2ludHM7XG5mcmVlemUoZ2V0QnJlYWtwb2ludHMpO1xuXG5jb25zdCBzZXRCcmVha3BvaW50cz0obmV3QnJlYWtwb2ludHM9YnJlYWtwb2ludHMpPT57XG5pc0pTT05SZWNvcmQobmV3QnJlYWtwb2ludHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uIHRvIGJlIGEgSlNPTiBicmVha3BvaW50cyByZWNvcmRgO1xuXG4vKiogQHR5cGUge0JyZWFrcG9pbnRUYWJsZX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbmNvbnN0IG5ld0JyZWFrcG9pbnRzVGFibGU9e19fcHJvdG9fXzpudWxsfTtcblxuZm9yKGNvbnN0W3RhZyxtZXRob2RCUHNdb2YgZW50cmllcyhuZXdCcmVha3BvaW50cykpe1xudGFnPT09c2ltcGxpZnlUYWcodGFnKXx8XG5GYWlsIGBKdXN0IHVzZSBzaW1wbGUgdGFnICR7cShzaW1wbGlmeVRhZyh0YWcpKX0gcmF0aGVyIHRoYW4gJHtxKHRhZyl9YDtcbmlzSlNPTlJlY29yZChtZXRob2RCUHMpfHxcbkZhaWwgYEV4cGVjdGVkICR7cShvcHRpb25OYW1lKX0gb3B0aW9uJ3MgJHtxKFxudGFnKVxuIH0gdG8gYmUgYSBKU09OIG1ldGhvZHMgYnJlYWtwb2ludHMgcmVjb3JkYDtcbmZvcihjb25zdFttZXRob2ROYW1lLGNvdW50XW9mIGVudHJpZXMobWV0aG9kQlBzKSl7XG5jb3VudD09PScqJ3x8XG50eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmXG5OdW1iZXIuaXNTYWZlSW50ZWdlcihjb3VudCkmJlxuY291bnQ+PTB8fFxuRmFpbCBgRXhwZWN0ZWQgJHtxKG9wdGlvbk5hbWUpfSBvcHRpb24ncyAke3EodGFnKX0uJHtxKFxubWV0aG9kTmFtZSlcbiB9IHRvIGJlIFwiKlwiIG9yIGEgbm9uLW5lZ2F0aXZlIGludGVnZXJgO1xuXG5jb25zdCBjbGFzc0JQcz1oYXNPd24obmV3QnJlYWtwb2ludHNUYWJsZSxtZXRob2ROYW1lKT9cbm5ld0JyZWFrcG9pbnRzVGFibGVbbWV0aG9kTmFtZV06XG5uZXdCcmVha3BvaW50c1RhYmxlW21ldGhvZE5hbWVdPXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY29uZnVzZWQgYnkgX19wcm90b19fKi9cbl9fcHJvdG9fXzpudWxsfTtcblxuY2xhc3NCUHNbdGFnXT1jb3VudDtcbiB9XG4gfVxuYnJlYWtwb2ludHM9bmV3QnJlYWtwb2ludHM7XG5icmVha3BvaW50c1RhYmxlPW5ld0JyZWFrcG9pbnRzVGFibGU7XG4gfTtcbmZyZWV6ZShzZXRCcmVha3BvaW50cyk7XG5cbmNvbnN0IHNob3VsZEJyZWFrcG9pbnQ9KHJlY2lwaWVudCxtZXRob2ROYW1lKT0+e1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZHx8bWV0aG9kTmFtZT09PW51bGwpe1xuLyogVE9ETyBlbmFibGUgZnVuY3Rpb24gYnJlYWtwb2ludGluZyovXG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgY2xhc3NCUHM9YnJlYWtwb2ludHNUYWJsZVttZXRob2ROYW1lXXx8YnJlYWtwb2ludHNUYWJsZVsnKiddO1xuaWYoY2xhc3NCUHM9PT11bmRlZmluZWQpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmxldCB0YWc9c2ltcGxpZnlUYWcocmVjaXBpZW50W1N5bWJvbC50b1N0cmluZ1RhZ10pO1xubGV0IGNvdW50PWNsYXNzQlBzW3RhZ107XG5pZihjb3VudD09PXVuZGVmaW5lZCl7XG50YWc9JyonO1xuY291bnQ9Y2xhc3NCUHNbdGFnXTtcbmlmKGNvdW50PT09dW5kZWZpbmVkKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuaWYoY291bnQ9PT0nKicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoY291bnQ9PT0wKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydCh0eXBlb2YgY291bnQ9PT0nbnVtYmVyJyYmY291bnQ+PTEpO1xuY2xhc3NCUHNbdGFnXT1jb3VudC0xO1xucmV0dXJuIGZhbHNlO1xuIH07XG5mcmVlemUoc2hvdWxkQnJlYWtwb2ludCk7XG5cbmNvbnN0IGJyZWFrcG9pbnRUZXN0ZXI9ZnJlZXplKHtcbmdldEJyZWFrcG9pbnRzLFxuc2V0QnJlYWtwb2ludHMsXG5zaG91bGRCcmVha3BvaW50fSk7XG5cbmJyZWFrcG9pbnRUZXN0ZXIuc2V0QnJlYWtwb2ludHMoKTtcbnJldHVybiBicmVha3BvaW50VGVzdGVyO1xuIH07JGjNj19vbmNlLm1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3RlcihtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIpO1xuZnJlZXplKG1ha2VNZXNzYWdlQnJlYWtwb2ludFRlc3Rlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTWVzc2FnZUJyZWFrcG9pbnRUZXN0ZXIiOlsibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABeEUwx5AwAAeQMAACkAAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvbm8tc2hpbS5qc3siaW1wb3J0cyI6WyIuL0UuanMiLCIuL2V4cG9ydHMuanMiXSwiZXhwb3J0cyI6WyJFIiwiSGFuZGxlZFByb21pc2UiXSwicmVleHBvcnRzIjpbIi4vZXhwb3J0cy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBtYWtlRTskaM2PX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbW1wiZGVmYXVsdFwiLCBbJGjNj19hID0+IChtYWtlRSA9ICRozY9fYSldXV1dLFtcIi4vZXhwb3J0cy5qc1wiLCBbXV1dKTsgICBcblxuLyogWFhYIG1vZHVsZSBleHBvcnRzIGZvciBIYW5kbGVkUHJvbWlzZSBmYWlsIGlmIHRoZXNlIGFyZW4ndCBpbiBzY29wZSovXG4vKiogQGltcG9ydCB7SGFuZGxlciwgSGFuZGxlZEV4ZWN1dG9yfSBmcm9tICcuL2hhbmRsZWQtcHJvbWlzZS5qcycgKi9cbi8qKiBAaW1wb3J0IHtFQ2FsbGFibGVPck1ldGhvZHMsIEVHZXR0ZXJzLCBFUmVmLCBFUmVtb3RlRnVuY3Rpb25zLCBFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kcywgTG9jYWxSZWNvcmQsIFJlbW90ZUZ1bmN0aW9uc30gZnJvbSAnLi9FLmpzJyAqL1xuXG5jb25zdCBocD1IYW5kbGVkUHJvbWlzZTskaM2PX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoaHApOyRozY9fb25jZS5FKEUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiSGFuZGxlZFByb21pc2UiOlsiaHAiXSwiRSI6WyJFIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB6458vtEAAA7RAAAC0AAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJ0cmFja1R1cm5zIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLGVudmlyb25tZW50T3B0aW9uc0xpc3RIYXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV0sW1wiZW52aXJvbm1lbnRPcHRpb25zTGlzdEhhc1wiLCBbJGjNj19hID0+IChlbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIFdlIGFsc28gY2Fubm90IGN1cnJlbnRseSBpbXBvcnQgdGhlbSBiZWNhdXNlIGl0IHdvdWxkIGNyZWF0ZSBhIGN5Y2xpYyovXG4vKiBkZXBlbmRlbmN5LCB0aG91Z2ggdGhpcyBpcyBtb3JlIGVhc2lseSBmaXhlZC4qL1xuLyogaW1wb3J0IHsgYXNzZXJ0LCBYLCBGYWlsIH0gZnJvbSAnQGVuZG8vZXJyb3JzJzsqL1xuLyogU2VlIGFsc28gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85NTE1Ki9cblxuLyogV0FSTklORzogR2xvYmFsIE11dGFibGUgU3RhdGUhKi9cbi8qIFRoaXMgc3RhdGUgaXMgY29tbXVuaWNhdGVkIHRvIGBhc3NlcnRgIHRoYXQgbWFrZXMgaXQgYXZhaWxhYmxlIHRvIHRoZSovXG4vKiBjYXVzYWwgY29uc29sZSwgd2hpY2ggYWZmZWN0cyB0aGUgY29uc29sZSBsb2cgb3V0cHV0LiBOb3JtYWxseSB3ZSovXG4vKiByZWdhcmQgdGhlIGFiaWxpdHkgdG8gc2VlIGNvbnNvbGUgbG9nIG91dHB1dCBhcyBhIG1ldGEtbGV2ZWwgcHJpdmlsZWdlKi9cbi8qIGFuYWxvZ291cyB0byB0aGUgYWJpbGl0eSB0byBkZWJ1Zy4gQXNpZGUgZnJvbSB0aGF0LCB0aGlzIG1vZHVsZSBzaG91bGQqL1xuLyogbm90IGhhdmUgYW55IG9ic2VydmFibHkgbXV0YWJsZSBzdGF0ZS4qL1xuXG5sZXQgaGlkZGVuUHJpb3JFcnJvcjtcbmxldCBoaWRkZW5DdXJyZW50VHVybj0wO1xubGV0IGhpZGRlbkN1cnJlbnRFdmVudD0wO1xuXG4vKiBUdXJuIG9uIGlmIHlvdSBzZWVtIHRvIGJlIGxvc2luZyBlcnJvciBsb2dnaW5nIGF0IHRoZSB0b3Agb2YgdGhlIGV2ZW50IGxvb3AqL1xuY29uc3QgVkVSQk9TRT1lbnZpcm9ubWVudE9wdGlvbnNMaXN0SGFzKCdERUJVRycsJ3RyYWNrLXR1cm5zJyk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBlbmFibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgRU5BQkxFRD1cbmdldEVudmlyb25tZW50T3B0aW9uKCdUUkFDS19UVVJOUycsJ2Rpc2FibGVkJyxbJ2VuYWJsZWQnXSk9PT0nZW5hYmxlZCc7XG5cbi8qIFdlIGhvaXN0IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIG91dCBvZiB0cmFja1R1cm5zKCkgdG8gZGlzY291cmFnZSB0aGUqL1xuLyogY2xvc3VyZXMgZnJvbSBob2xkaW5nIG9udG8gJ2FyZ3MnIG9yICdmdW5jJyBsb25nZXIgdGhhbiBuZWNlc3NhcnksKi9cbi8qIHdoaWNoIHdlJ3ZlIHNlZW4gY2F1c2UgSGFuZGxlZFByb21pc2UgYXJndW1lbnRzIHRvIGJlIHJldGFpbmVkIGZvciovXG4vKiBhIHN1cnByaXNpbmdseSBsb25nIHRpbWUuKi9cblxuY29uc3QgYWRkUmVqZWN0aW9uTm90ZT0oZGV0YWlsc05vdGUpPT4ocmVhc29uKT0+e1xuaWYocmVhc29uIGluc3RhbmNlb2YgRXJyb3Ipe1xuZ2xvYmFsVGhpcy5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9O1xuXG5jb25zdCB3cmFwRnVuY3Rpb249XG4oZnVuYyxzZW5kaW5nRXJyb3IsWCk9PlxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5nbG9iYWxUaGlzLmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goYWRkUmVqZWN0aW9uTm90ZShkZXRhaWxzTm90ZSkpO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9O1xuXG4vKipcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAdGVtcGxhdGUge1R1cm5TdGFydGVyRm5bXX0gVFxuICogQHBhcmFtIHtUfSBmdW5jc1xuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICB0cmFja1R1cm5zPShmdW5jcyk9PntcbmlmKCFFTkFCTEVEfHx0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WCxub3RlOmFubm90YXRlRXJyb3J9PWdsb2JhbFRoaXMuYXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9RXJyb3IoXG4gYEV2ZW50OiAke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuaWYoaGlkZGVuUHJpb3JFcnJvciE9PXVuZGVmaW5lZCl7XG5hbm5vdGF0ZUVycm9yKHNlbmRpbmdFcnJvcixYIGBDYXVzZWQgYnk6ICR7aGlkZGVuUHJpb3JFcnJvcn1gKTtcbiB9XG5cbnJldHVybiAoLyoqIEB0eXBlIHtUfSAqL1xuZnVuY3MubWFwKChmdW5jKT0+ZnVuYyYmd3JhcEZ1bmN0aW9uKGZ1bmMsc2VuZGluZ0Vycm9yLFgpKSk7XG5cbiB9O1xuXG4vKipcbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICpcbiAqIEB0eXBlZGVmIHsoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgdW5kZWZpbmVkfSBUdXJuU3RhcnRlckZuXG4gKi8kaM2PX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InRyYWNrVHVybnMiOlsidHJhY2tUdXJucyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA/8Oc6VgIAAFYCAAAjAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvdXRpbHMuanN7ImltcG9ydHMiOlsiLi9zcmMvbG9jYWwuanMiLCIuL3NyYy9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzIl0sImV4cG9ydHMiOltudWxsLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbW1wiLi9zcmMvbG9jYWwuanNcIiwgW11dLFtcIi4vc3JjL21lc3NhZ2UtYnJlYWtwb2ludHMuanNcIiwgW11dXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9sb2NhbC5qcyI6W1siZ2V0TWV0aG9kTmFtZXMiLCJnZXRNZXRob2ROYW1lcyJdXSwiLi9zcmMvbWVzc2FnZS1icmVha3BvaW50cy5qcyI6W1sibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIiwibWFrZU1lc3NhZ2VCcmVha3BvaW50VGVzdGVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC4gWnwdAcAAHQHAAAdAAAAQGVuZG8vbWFyc2hhbC12MS42LjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9zcmMvbWFyc2hhbC5qcyIsIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIiwiLi9zcmMvbWFyc2hhbC1qdXN0aW4uanMiLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyIsIi4vc3JjL3JhbmtPcmRlci5qcyIsIi4vc3JjL3R5cGVzLmpzIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImFzc2VydFJhbmtTb3J0ZWQiLCJhc3NlcnRSYW5rU29ydGVkIiwibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIiwicGFyc2UiLCJwYXJzZSIsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW1tcIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtanVzdGluLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvcmFua09yZGVyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbXV1dKTsgICBcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyI6W1siUUNMQVNTIiwiUUNMQVNTIl1dLCIuL3NyYy9tYXJzaGFsLmpzIjpbWyJtYWtlTWFyc2hhbCIsIm1ha2VNYXJzaGFsIl1dLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6W1sic3RyaW5naWZ5Iiwic3RyaW5naWZ5Il0sWyJwYXJzZSIsInBhcnNlIl1dLCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6W1siZGVjb2RlVG9KdXN0aW4iLCJkZWNvZGVUb0p1c3RpbiJdXSwiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOltbIm1ha2VQYXNzYWJsZUtpdCIsIm1ha2VQYXNzYWJsZUtpdCJdLFsibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIl0sWyJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiXSxbImlzRW5jb2RlZFJlbW90YWJsZSIsImlzRW5jb2RlZFJlbW90YWJsZSJdLFsiemVyb1BhZCIsInplcm9QYWQiXSxbInJlY29yZE5hbWVzIiwicmVjb3JkTmFtZXMiXSxbInJlY29yZFZhbHVlcyIsInJlY29yZFZhbHVlcyJdXSwiLi9zcmMvcmFua09yZGVyLmpzIjpbWyJ0cml2aWFsQ29tcGFyYXRvciIsInRyaXZpYWxDb21wYXJhdG9yIl0sWyJhc3NlcnRSYW5rU29ydGVkIiwiYXNzZXJ0UmFua1NvcnRlZCJdLFsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayJdLFsiaXNSYW5rU29ydGVkIiwiaXNSYW5rU29ydGVkIl0sWyJzb3J0QnlSYW5rIiwic29ydEJ5UmFuayJdLFsiY29tcGFyZUFudGlSYW5rIiwiY29tcGFyZUFudGlSYW5rIl0sWyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0Il0sWyJnZXRQYXNzU3R5bGVDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIl0sWyJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaW50ZXJzZWN0UmFua0NvdmVycyJdLFsidW5pb25SYW5rQ292ZXJzIiwidW5pb25SYW5rQ292ZXJzIl1dLCJAZW5kby9wYXNzLXN0eWxlIjpbWyJkZWVwbHlGdWxmaWxsZWQiLCJkZWVwbHlGdWxmaWxsZWQiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3YsG7LbwAAy28AACoAAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlUGFzc2FibGUuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImlzRW5jb2RlZFJlbW90YWJsZSIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsIm1ha2VFbmNvZGVQYXNzYWJsZSIsIm1ha2VQYXNzYWJsZUtpdCIsInBhc3NTdHlsZVByZWZpeGVzIiwicmVjb3JkTmFtZXMiLCJyZWNvcmRWYWx1ZXMiLCJ6ZXJvUGFkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldFRhZyxtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGFzc2VydFJlY29yZCxpc0Vycm9yTGlrZSxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLGIscSxGYWlsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiYXNzZXJ0UmVjb3JkXCIsIFskaM2PX2EgPT4gKGFzc2VydFJlY29yZCA9ICRozY9fYSldXSxbXCJpc0Vycm9yTGlrZVwiLCBbJGjNj19hID0+IChpc0Vycm9yTGlrZSA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcImJcIiwgWyRozY9fYSA9PiAoYiA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtmcm9tRW50cmllcyxpc309T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcblxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnRyb2wtcmVnZXgqL1xuY29uc3QgckMwPS9bXFx4MDAtXFx4MUZdLztcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHN1ZmZpeCBvZiBhIHN0cmluZyBzdGFydGluZyBhdCBhIHBhcnRpY3VsYXIgaW5kZXguXG4gKiBUaGlzIGJvdGggZXhwcmVzc2VzIGludGVudCBhbmQgcG90ZW50aWFsbHkgYXZvaWRzIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODRcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyXG4gKiBAcGFyYW0ge251bWJlcn0gaW5kZXhcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGdldFN1ZmZpeD0oc3RyLGluZGV4KT0+aW5kZXg9PT0wP3N0cjpzdHIuc3Vic3RyaW5nKGluZGV4KTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCwgd2UgaGF2ZSBvbmx5XG4gKiBzdHJpbmctbmFtZWQgb3duIHByb3BlcnRpZXMuIGByZWNvcmROYW1lc2AgcmV0dXJucyB0aG9zZSBuYW1lICpyZXZlcnNlKlxuICogc29ydGVkLCBiZWNhdXNlIHRoYXQncyBob3cgcmVjb3JkcyBhcmUgY29tcGFyZWQsIGVuY29kZWQsIGFuZCBzb3J0ZWQuXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZE5hbWVzPShyZWNvcmQpPT5cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNjAjZGlzY3Vzc2lvbl9yMTAwMzY1NzI0NCovXG4vKiBjb21wYXJlcyB0d28gd2F5cyBvZiByZXZlcnNlIHNvcnRpbmcsIGFuZCBzaG93cyB0aGF0IGAuc29ydCgpLnJldmVyc2UoKWAqL1xuLyogaXMgY3VycmVudGx5IGZhc3RlciBvbiBNb2RkYWJsZSBYUywgd2hpbGUgdGhlIG90aGVyIHdheSwqL1xuLyogYC5zb3J0KHJldmVyc2VDb21wYXJhdG9yKWAsIGlzIGZhc3RlciBvbiB2OC4gV2UgY3VycmVudGx5IGNhcmUgbW9yZSBhYm91dCovXG4vKiBYUyBwZXJmb3JtYW5jZSwgc28gd2UgcmV2ZXJzZSBzb3J0IHVzaW5nIGAuc29ydCgpLnJldmVyc2UoKWAuKi9cbmhhcmRlbigvKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjb3JkKS5zb3J0KCkucmV2ZXJzZSgpKTskaM2PX29uY2UucmVjb3JkTmFtZXMocmVjb3JkTmFtZXMpO1xuaGFyZGVuKHJlY29yZE5hbWVzKTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCBhbmQgYG5hbWVzYCBpcyBgcmVjb3JkTmFtZXMocmVjb3JkKWAsXG4gKiByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcgYXJyYXkgb2YgcHJvcGVydHkgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxUPn0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBuYW1lc1xuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZFZhbHVlcz0ocmVjb3JkLG5hbWVzKT0+XG5oYXJkZW4obmFtZXMubWFwKChuYW1lKT0+cmVjb3JkW25hbWVdKSk7JGjNj19vbmNlLnJlY29yZFZhbHVlcyhyZWNvcmRWYWx1ZXMpO1xuaGFyZGVuKHJlY29yZFZhbHVlcyk7XG5cbmNvbnN0IHplcm9lcz1BcnJheSgxNikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8saSk9PicwJy5yZXBlYXQoaSkpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gblxuICogQHBhcmFtIHtudW1iZXJ9IHNpemVcbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICB6ZXJvUGFkPShuLHNpemUpPT57XG5jb25zdCBuU3RyPSBgJHtufWA7XG5jb25zdCBmaWxsTGVuPXNpemUtblN0ci5sZW5ndGg7XG5pZihmaWxsTGVuPT09MClyZXR1cm4gblN0cjtcbmFzc2VydChmaWxsTGVuPjAmJmZpbGxMZW48emVyb2VzLmxlbmd0aCk7XG5yZXR1cm4gYCR7emVyb2VzW2ZpbGxMZW5dfSR7blN0cn1gO1xuIH07JGjNj19vbmNlLnplcm9QYWQoemVyb1BhZCk7XG5oYXJkZW4oemVyb1BhZCk7XG5cbi8qIFRoaXMgaXMgdGhlIEphdmFTY3JpcHQgYW5hbG9nIHRvIGEgQyB1bmlvbjogYSB3YXkgdG8gbWFwIGJldHdlZW4gYSBmbG9hdCBhcyBhKi9cbi8qIG51bWJlciBhbmQgdGhlIGJpdHMgdGhhdCByZXByZXNlbnQgdGhlIGZsb2F0IGFzIGEgYnVmZmVyIGZ1bGwgb2YgYnl0ZXMuICBOb3RlKi9cbi8qIHRoYXQgdGhlIG11dGF0aW9uIG9mIHN0YXRpYyBzdGF0ZSBoZXJlIG1ha2VzIHRoaXMgaW52YWxpZCBKZXNzaWUgY29kZSwgYnV0Ki9cbi8qIGRvaW5nIGl0IHRoaXMgd2F5IHNhdmVzIHRoZSBudWdhdG9yeSBhbmQgZ3JhdHVpdG91cyBhbGxvY2F0aW9ucyB0aGF0IHdvdWxkKi9cbi8qIGhhcHBlbiBldmVyeSB0aW1lIHlvdSBkbyBhIGNvbnZlcnNpb24gLS0gYW5kIGluIHByYWN0aWNhbCB0ZXJtcyBpdCdzIHNhZmUqL1xuLyogYmVjYXVzZSB3ZSBwdXQgdGhlIHZhbHVlIGluIG9uZSBzaWRlIGFuZCB0aGVuIGltbWVkaWF0ZWx5IHRha2UgaXQgb3V0IHRoZSovXG4vKiBvdGhlcjsgdGhlcmUgaXMgbm8gYWN0dWFsIHN0YXRlIHJldGFpbmVkIGluIHRoZSBjbGFzc2ljIHNlbnNlIGFuZCB0aHVzIG5vKi9cbi8qIHJlLWVudHJhbmN5IGlzc3VlLiovXG5jb25zdCBhc051bWJlcj1uZXcgRmxvYXQ2NEFycmF5KDEpO1xuY29uc3QgYXNCaXRzPW5ldyBCaWdVaW50NjRBcnJheShhc051bWJlci5idWZmZXIpO1xuXG4vKiBKYXZhU2NyaXB0IG51bWJlcnMgYXJlIGVuY29kZWQgYnkgb3V0cHV0dGluZyB0aGUgYmFzZS0xNiovXG4vKiByZXByZXNlbnRhdGlvbiBvZiB0aGUgYmluYXJ5IHZhbHVlIG9mIHRoZSB1bmRlcmx5aW5nIElFRUUgZmxvYXRpbmcgcG9pbnQqL1xuLyogcmVwcmVzZW50YXRpb24uICBGb3IgbmVnYXRpdmUgdmFsdWVzLCBhbGwgYml0cyBvZiB0aGlzIHJlcHJlc2VudGF0aW9uIGFyZSovXG4vKiBjb21wbGVtZW50ZWQgcHJpb3IgdG8gdGhlIGJhc2UtMTYgY29udmVyc2lvbiwgd2hpbGUgZm9yIHBvc2l0aXZlIHZhbHVlcywgdGhlKi9cbi8qIHNpZ24gYml0IGlzIGNvbXBsZW1lbnRlZC4gIFRoaXMgZW5zdXJlcyBib3RoIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYmVmb3JlKi9cbi8qIHBvc2l0aXZlIHZhbHVlcyBhbmQgdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgc29ydCBhY2NvcmRpbmcgdG8gdGhlaXIgbmVnYXRpdmUqL1xuLyogbWFnbml0dWRlIHJhdGhlciB0aGFuIHRoZWlyIHBvc2l0aXZlIG1hZ25pdHVkZS4gIFRoaXMgcmVzdWx0cyBpbiBhbiBBU0NJSSovXG4vKiBlbmNvZGluZyB3aG9zZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgaXMgdGhlIHNhbWUgYXMgdGhlIG51bWVyaWMgc29ydCBvcmRlciovXG4vKiBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLiovXG5cbi8qIFRPRE8gQ2hvb3NlIHRoZSBzYW1lIGNhbm9uaWNhbCBOYU4gZW5jb2RpbmcgdGhhdCBjb3NtV2FzbSBhbmQgZXdhc20gY2hvc2UuKi9cbmNvbnN0IENhbm9uaWNhbE5hTkJpdHM9J2ZmZjgwMDAwMDAwMDAwMDAnO1xuXG4vKipcbiAqIEBwYXJhbSB7bnVtYmVyfSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaW5hcnk2ND0obik9Pntcbi8qIE5vcm1hbGl6ZSAtMCB0byAwIGFuZCBOYU4gdG8gYSBjYW5vbmljYWwgZW5jb2RpbmcqL1xuaWYoaXMobiwtMCkpe1xubj0wO1xuIH1lbHNlIGlmKGlzKG4sTmFOKSl7XG5yZXR1cm4gYGYke0Nhbm9uaWNhbE5hTkJpdHN9YDtcbiB9XG5hc051bWJlclswXT1uO1xubGV0IGJpdHM9YXNCaXRzWzBdO1xuaWYobjwwKXtcbmJpdHNePTB4ZmZmZmZmZmZmZmZmZmZmZm47XG4gfWVsc2V7XG5iaXRzXj0weDgwMDAwMDAwMDAwMDAwMDBuO1xuIH1cbnJldHVybiBgZiR7emVyb1BhZChiaXRzLnRvU3RyaW5nKDE2KSwxNil9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGVCaW5hcnk2ND0oZW5jb2RlZCxza2lwPTApPT57XG5lbmNvZGVkLmNoYXJBdChza2lwKT09PSdmJ3x8RmFpbCBgRW5jb2RlZCBudW1iZXIgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IGJpdHM9QmlnSW50KCBgMHgke2dldFN1ZmZpeChlbmNvZGVkLHNraXArMSl9YCk7XG5pZihlbmNvZGVkLmNoYXJBdChza2lwKzEpPCc4Jyl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5hc0JpdHNbMF09Yml0cztcbmNvbnN0IHJlc3VsdD1hc051bWJlclswXTtcbiFpcyhyZXN1bHQsLTApfHxcbkZhaWwgYFVuZXhwZWN0ZWQgbmVnYXRpdmUgemVybzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEVuY29kZSBhIEphdmFTY3JpcHQgYmlnaW50IHVzaW5nIGEgdmFyaWFudCBvZiBFbGlhcyBkZWx0YSBjb2RpbmcsIHdpdGggYW5cbiAqIGluaXRpYWwgY29tcG9uZW50IGZvciB0aGUgbGVuZ3RoIG9mIHRoZSBkaWdpdCBjb3VudCBhcyBhIHVuYXJ5IHN0cmluZywgYVxuICogc2Vjb25kIGNvbXBvbmVudCBmb3IgdGhlIGRlY2ltYWwgZGlnaXQgY291bnQsIGFuZCBhIHRoaXJkIGNvbXBvbmVudCBmb3IgdGhlXG4gKiBkZWNpbWFsIGRpZ2l0cyBwcmVjZWRlZCBieSBhIGdyYXR1aXRvdXMgc2VwYXJhdGluZyBjb2xvbi5cbiAqIFRvIGVuc3VyZSB0aGF0IHRoZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgb2YgZW5jb2RlZCB2YWx1ZXMgbWF0Y2hlcyB0aGVcbiAqIG51bWVyaWMgc29ydCBvcmRlciBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLCB0aGUgY2hhcmFjdGVycyBvZiB0aGUgdW5hcnlcbiAqIHByZWZpeCBhcmUgZGlmZmVyZW50IGZvciBuZWdhdGl2ZSB2YWx1ZXMgKHR5cGUgXCJuXCIgZm9sbG93ZWQgYnkgYW55IG51bWJlciBvZlxuICogXCIjXCJzIFt3aGljaCBzb3J0IGJlZm9yZSBkZWNpbWFsIGRpZ2l0c10pIHZzLiBwb3NpdGl2ZSBhbmQgemVybyB2YWx1ZXMgKHR5cGVcbiAqIFwicFwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2YgXCJ+XCJzIFt3aGljaCBzb3J0IGFmdGVyIGRlY2ltYWwgZGlnaXRzXSkgYW5kXG4gKiBlYWNoIGRlY2ltYWwgZGlnaXQgb2YgdGhlIGVuY29kaW5nIGZvciBhIG5lZ2F0aXZlIHZhbHVlIGlzIHJlcGxhY2VkIHdpdGggaXRzXG4gKiB0ZW4ncyBjb21wbGVtZW50IChzbyB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBvZiB0aGUgc2FtZSBzY2FsZSBzb3J0IGJ5XG4gKiAqZGVzY2VuZGluZyogYWJzb2x1dGUgdmFsdWUpLlxuICpcbiAqIEBwYXJhbSB7YmlnaW50fSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaWdJbnQ9KG4pPT57XG5jb25zdCBhYnM9bjwwbj8tbjpuO1xuY29uc3QgbkRpZ2l0cz1hYnMudG9TdHJpbmcoKS5sZW5ndGg7XG5jb25zdCBsRGlnaXRzPW5EaWdpdHMudG9TdHJpbmcoKS5sZW5ndGg7XG5pZihuPDBuKXtcbnJldHVybiBgbiR7XG4vKiBBIFwiI1wiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJyMnLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgY291bnQgb2YgZGlnaXRzLiovXG4oMTAqKmxEaWdpdHMtbkRpZ2l0cykudG9TdHJpbmcoKS5wYWRTdGFydChsRGlnaXRzLCcwJylcbiB9OiR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgZGlnaXRzLiovXG4oMTBuKipCaWdJbnQobkRpZ2l0cykrbikudG9TdHJpbmcoKS5wYWRTdGFydChuRGlnaXRzLCcwJylcbiB9YDtcbiB9ZWxzZXtcbnJldHVybiBgcCR7XG4vKiBBIFwiflwiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJ34nLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgY291bnQgb2YgZGlnaXRzLiovXG5uRGlnaXRzXG4gfToke1xuLyogVGhlIGRpZ2l0cy4qL1xublxuIH1gO1xuIH1cbiB9O1xuXG5jb25zdCByQmlnSW50UGF5bG9hZD0vKFswLTldKykoOihbMC05XSskfCl8KS9zO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5jb25zdCBkZWNvZGVCaWdJbnQ9KGVuY29kZWQpPT57XG5jb25zdCB0eXBlUHJlZml4PWVuY29kZWQuY2hhckF0KDApOy8qIGZhc3RlciB0aGFuIGVuY29kZWRbMF0qL1xudHlwZVByZWZpeD09PSdwJ3x8XG50eXBlUHJlZml4PT09J24nfHxcbkZhaWwgYEVuY29kZWQgYmlnaW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcblxuY29uc3R7XG5pbmRleDpsRGlnaXRzLFxuMTpzbkRpZ2l0cyxcbjI6dGFpbCxcbjM6ZGlnaXRzfT1cbmVuY29kZWQubWF0Y2gockJpZ0ludFBheWxvYWQpfHxGYWlsIGBEaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5cbnNuRGlnaXRzLmxlbmd0aD09PWxEaWdpdHN8fFxuRmFpbCBgVW5hcnktcHJlZml4ZWQgZGVjaW1hbCBkaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgbkRpZ2l0cz1wYXJzZUludChzbkRpZ2l0cywxMCk7XG5pZih0eXBlUHJlZml4PT09J24nKXtcbi8qIFRPRE8gQXNzZXJ0IHRvIHJlamVjdCBmb3JiaWRkZW4gZW5jb2RpbmdzKi9cbi8qIGxpa2UgXCJuMDpcIiBhbmQgXCJuMDA64oCmXCIgYW5kIFwibjkxOuKAplwiIHRocm91Z2ggXCJuOTk64oCmXCI/Ki9cbm5EaWdpdHM9MTAqKi8qKiBAdHlwZSB7bnVtYmVyfSAqL2xEaWdpdHMtbkRpZ2l0cztcbiB9XG5cbnRhaWwuY2hhckF0KDApPT09JzonfHxGYWlsIGBTZXBhcmF0b3IgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xuZGlnaXRzLmxlbmd0aD09PW5EaWdpdHN8fFxuRmFpbCBgRml4ZWQtbGVuZ3RoIGRpZ2l0IHNlcXVlbmNlIGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmxldCBuPUJpZ0ludChkaWdpdHMpO1xuaWYodHlwZVByZWZpeD09PSduJyl7XG4vKiBUT0RPIEFzc2VydCB0byByZWplY3QgZm9yYmlkZGVuIGVuY29kaW5ncyovXG4vKiBsaWtlIFwibjk6MFwiIGFuZCBcIm44OjAwXCIgYW5kIFwibjg6OTFcIiB0aHJvdWdoIFwibjg6OTlcIj8qL1xubj0tKDEwbioqQmlnSW50KG5EaWdpdHMpLW4pO1xuIH1cblxucmV0dXJuIG47XG4gfTtcblxuLyoqXG4gKiBBIHNwYXJzZSBhcnJheSBmb3Igd2hpY2ggZXZlcnkgcHJlc2VudCBpbmRleCBtYXBzIGEgY29kZSBwb2ludCBpbiB0aGUgQVNDSUlcbiAqIHJhbmdlIHRvIGEgY29ycmVzcG9uZGluZyBlc2NhcGUgc2VxdWVuY2UuXG4gKlxuICogRXNjYXBlcyBhbGwgY2hhcmFjdGVycyBmcm9tIFUrMDAwMCBOVUxMIHRvIFUrMDAxRiBJTkZPUk1BVElPTiBTRVBBUkFUT1IgT05FXG4gKiBsaWtlIGAhPGNoYXJhY3RlciBvZmZzZXQgYnkgMHgyMT5gIHRvIGF2b2lkIEpTT04uc3RyaW5naWZ5IGV4cGFuc2lvbiBhc1xuICogYFxcdUhISEhgLCBhbmQgc3BlY2lhbGx5IGVzY2FwZXMgVSswMDIwIFNQQUNFICh0aGUgYXJyYXkgZWxlbWVudCB0ZXJtaW5hdG9yKVxuICogYXMgYCFfYCBhbmQgVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgKHRoZSBlc2NhcGUgcHJlZml4KSBhcyBgIXxgIChib3RoIGNob3NlblxuICogZm9yIHZpc3VhbCBhcHByb3hpbWF0aW9uKS5cbiAqIFJlbGF0aXZlIGxleGljb2dyYXBoaWMgb3JkZXJpbmcgaXMgcHJlc2VydmVkIGJ5IHRoaXMgbWFwcGluZyBvZiBhbnkgY2hhcmFjdGVyXG4gKiBhdCBvciBiZWZvcmUgYCFgIGluIHRoZSBjb250aWd1b3VzIHJhbmdlIFsweDAwLi4weDIxXSB0byBhIHJlc3BlY3RpdmVcbiAqIGNoYXJhY3RlciBpbiBbMHgyMS4uMHg0MCwgMHg1RiwgMHg3Q10gcHJlY2VkZWQgYnkgYCFgICh3aGljaCBpcyBpdHNlbGYgaW4gdGhlXG4gKiByZXBsYWNlZCByYW5nZSkuXG4gKiBTaW1pbGFybHksIGVzY2FwZXMgYF5gIGFzIGBfQGAgYW5kIGBfYCBhcyBgX19gIGJlY2F1c2UgYF5gIGluZGljYXRlcyB0aGVcbiAqIHN0YXJ0IG9mIGFuIGVuY29kZWQgYXJyYXkuXG4gKlxuICogQHR5cGUge0FycmF5PHN0cmluZz59XG4gKi9cbmNvbnN0IHN0cmluZ0VzY2FwZXM9QXJyYXkoMHgyMikuXG5maWxsKHVuZGVmaW5lZCkuXG5tYXAoKF8sY3ApPT57XG5zd2l0Y2goU3RyaW5nLmZyb21DaGFyQ29kZShjcCkpe1xuY2FzZScgJzpcbnJldHVybichXyc7XG5jYXNlJyEnOlxucmV0dXJuJyF8JztcbmRlZmF1bHQ6XG5yZXR1cm4gYCEke1N0cmluZy5mcm9tQ2hhckNvZGUoY3ArMHgyMSl9YDt9XG5cbiB9KTtcbnN0cmluZ0VzY2FwZXNbJ14nLmNoYXJDb2RlQXQoMCldPSdfQCc7XG5zdHJpbmdFc2NhcGVzWydfJy5jaGFyQ29kZUF0KDApXT0nX18nO1xuXG4vKipcbiAqIEVuY29kZXMgYSBzdHJpbmcgd2l0aCBlc2NhcGUgc2VxdWVuY2VzIGZvciB1c2UgaW4gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhzdHI6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVDb21wYWN0U3RyaW5nU3VmZml4PShzdHIpPT5cbnN0ci5yZXBsYWNlKC9bXFwwLSFeX10vZywoY2gpPT5zdHJpbmdFc2NhcGVzW2NoLmNoYXJDb2RlQXQoMCldKTtcblxuLyoqXG4gKiBEZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwiY29tcGFjdE9yZGVyZWRcIiBmb3JtYXQuXG4gKlxuICogQHR5cGUgeyhlbmNvZGVkOiBzdHJpbmcpID0+IHN0cmluZ31cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeD0oZW5jb2RlZCk9PntcbnJldHVybiBlbmNvZGVkLnJlcGxhY2UoLyhbXFwwLSFfXSkoLnxcXG4pPy9nLChlc2MscHJlZml4LHN1ZmZpeCk9PntcbnN3aXRjaChlc2Mpe1xuY2FzZSchXyc6XG5yZXR1cm4nICc7XG5jYXNlJyF8JzpcbnJldHVybichJztcbmNhc2UnX0AnOlxucmV0dXJuJ14nO1xuY2FzZSdfXyc6XG5yZXR1cm4nXyc7XG5kZWZhdWx0OntcbmNvbnN0IGNoPS8qKiBAdHlwZSB7c3RyaW5nfSAqL3N1ZmZpeDtcbi8qIFRoZSByYW5nZSBvZiB2YWxpZCBgIWAtZXNjYXBlIHN1ZmZpeGVzIGlzIFsoMHgwMCsweDIxKS4uKDB4MUYrMHgyMSldLCBpLmUuKi9cbi8qIFsweDIxLi4weDQwXSAoVSswMDIxIEVYQ0xBTUFUSU9OIE1BUksgdG8gVSswMDQwIENPTU1FUkNJQUwgQVQpLiovXG5wcmVmaXg9PT0nIScmJnN1ZmZpeCE9PXVuZGVmaW5lZCYmY2g+PSchJyYmY2g8PSdAJ3x8XG5GYWlsIGBpbnZhbGlkIHN0cmluZyBlc2NhcGU6ICR7cShlc2MpfWA7XG5yZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZShjaC5jaGFyQ29kZUF0KDApLTB4MjEpO1xuIH19XG5cbiB9KTtcbiB9O1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1lbmNvZGVzIGEgc3RyaW5nIGZvciB1c2UgaW4gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IGVuY29kZUxlZ2FjeVN0cmluZ1N1ZmZpeD0oc3RyKT0+c3RyO1xuXG4vKipcbiAqIFRyaXZpYWxseSBpZGVudGl0eS1kZWNvZGVzIGEgc3RyaW5nIGZyb20gdGhlIFwibGVnYWN5T3JkZXJlZFwiIGZvcm1hdC5cbiAqXG4gKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfVxuICovXG5jb25zdCBkZWNvZGVMZWdhY3lTdHJpbmdTdWZmaXg9KGVuY29kZWQpPT5lbmNvZGVkO1xuXG4vKipcbiAqIEVuY29kZXMgYW4gYXJyYXkgaW50byBhIHNlcXVlbmNlIG9mIGVuY29kZWQgZWxlbWVudHMgZm9yIHVzZSBpbiB0aGUgXCJjb21wYWN0T3JkZXJlZFwiXG4gKiBmb3JtYXQsIGVhY2ggdGVybWluYXRlZCBieSBhIHNwYWNlICh3aGljaCBpcyBwYXJ0IG9mIHRoZSBlc2NhcGVkIHJhbmdlIGluXG4gKiBcImNvbXBhY3RPcmRlcmVkXCIgZW5jb2RlZCBzdHJpbmdzKS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQ29tcGFjdEFycmF5PShhcnJheSxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IGNoYXJzPVsnXiddO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgYXJyYXkpe1xuY29uc3QgZW5jPWVuY29kZVBhc3NhYmxlKGVsZW1lbnQpO1xuY2hhcnMucHVzaChlbmMsJyAnKTtcbiB9XG5yZXR1cm4gY2hhcnMuam9pbignJyk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHBhcmFtIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX0gZGVjb2RlUGFzc2FibGVcbiAqIEBwYXJhbSB7bnVtYmVyfSBbc2tpcF1cbiAqIEByZXR1cm5zIHtBcnJheX1cbiAqL1xuY29uc3QgZGVjb2RlQ29tcGFjdEFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xubGV0IGRlcHRoPTA7XG4vKiBTY2FuIGVuY29kZWQgcmF0aGVyIHRoYW4gaXRzIHRhaWwgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmxldCBuZXh0SW5kZXg9c2tpcCsxO1xubGV0IGN1cnJlbnRFbGVtZW50U3RhcnQ9c2tpcCsxO1xuZm9yKGNvbnN0ezA6Y2gsaW5kZXg6aX1vZiBlbmNvZGVkLm1hdGNoQWxsKC9bXFxeIF0vZykpe1xuY29uc3QgaW5kZXg9LyoqIEB0eXBlIHtudW1iZXJ9ICovaTtcbmlmKGluZGV4PD1za2lwKXtcbmlmKGluZGV4PT09c2tpcCl7XG5jaD09PSdeJ3x8RmFpbCBgRW5jb2RlZCBhcnJheSBleHBlY3RlZDogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuIH1cbiB9ZWxzZSBpZihjaD09PSdeJyl7XG4vKiBUaGlzIGlzIHRoZSBzdGFydCBvZiBhIG5lc3RlZCBhcnJheS4qL1xuLyogVE9ETzogU2luY2UgdGhlIHN5bnRheCBvZiBuZXN0ZWQgYXJyYXlzIG11c3QgYmUgdmFsaWRhdGVkIGFzIHBhcnQgb2YqL1xuLyogZGVjb2RpbmcgdGhlIG91dGVyIG9uZSwgY29uc2lkZXIgZGVjb2RpbmcgdGhlbSBoZXJlIGludG8gYSBzaGFyZWQgY2FjaGUqL1xuLyogcmF0aGVyIHRoYW4gZGlzY2FyZGluZyBpbmZvcm1hdGlvbiBhYm91dCB0aGVpciBjb250ZW50cyB1bnRpbCB0aGUgbGF0ZXIqL1xuLyogZGVjb2RlUGFzc2FibGUuKi9cbmRlcHRoKz0xO1xuIH1lbHNle1xuLyogVGhpcyBpcyBhIHRlcm1pbmF0ZWQgZWxlbWVudC4qL1xuaWYoaW5kZXg9PT1uZXh0SW5kZXgpe1xuLyogQSB0ZXJtaW5hdG9yIGFmdGVyIGBbYCBvciBhbiBhbm90aGVyIHRlcm1pbmF0b3IgaW5kaWNhdGVzIHRoYXQgYW4gYXJyYXkgaXMgZG9uZS4qL1xuZGVwdGgtPTE7XG5kZXB0aD49MHx8XG4vKiBwcmV0dGllci1pZ25vcmUqL1xuRmFpbCBgdW5leHBlY3RlZCBhcnJheSBlbGVtZW50IHRlcm1pbmF0b3I6ICR7ZW5jb2RlZC5zbGljZShza2lwLGluZGV4KzIpfWA7XG4gfVxuaWYoZGVwdGg9PT0wKXtcbi8qIFdlIGhhdmUgYSBjb21wbGV0ZSBlbGVtZW50IG9mIHRoZSB0b3Btb3N0IGFycmF5LiovXG5lbGVtZW50cy5wdXNoKFxuZGVjb2RlUGFzc2FibGUoZW5jb2RlZC5zbGljZShjdXJyZW50RWxlbWVudFN0YXJ0LGluZGV4KSkpO1xuXG5jdXJyZW50RWxlbWVudFN0YXJ0PWluZGV4KzE7XG4gfVxuIH1cbi8qIEFkdmFuY2UgdGhlIGluZGV4LiovXG5uZXh0SW5kZXg9aW5kZXgrMTtcbiB9XG5kZXB0aD09PTB8fEZhaWwgYHVudGVybWluYXRlZCBhcnJheTogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xubmV4dEluZGV4PT09ZW5jb2RlZC5sZW5ndGh8fFxuRmFpbCBgdW50ZXJtaW5hdGVkIGFycmF5IGVsZW1lbnQ6ICR7Z2V0U3VmZml4KFxuZW5jb2RlZCxcbmN1cnJlbnRFbGVtZW50U3RhcnQpXG4gfWA7XG5yZXR1cm4gaGFyZGVuKGVsZW1lbnRzKTtcbiB9O1xuXG4vKipcbiAqIFBlcmZvcm1zIHRoZSBvcmlnaW5hbCBhcnJheSBlbmNvZGluZywgd2hpY2ggZXNjYXBlcyBhbGwgZW5jb2RlZCBhcnJheVxuICogZWxlbWVudHMgcmF0aGVyIHRoYW4ganVzdCBzdHJpbmdzIChgXFx1MDAwMGAgYXMgdGhlIGVsZW1lbnQgdGVybWluYXRvciBhbmRcbiAqIGBcXHUwMDAxYCBhcyB0aGUgZXNjYXBlIHByZWZpeCBmb3IgYFxcdTAwMDBgIG9yIGBcXHUwMDAxYCkuXG4gKiBUaGlzIG5lY2Vzc2l0YXRlZCBhbiB1bmRlc2lyYWJsZSBhbW91bnQgb2YgaXRlcmF0aW9uIGFuZCBleHBhbnNpb247IHNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI2MCNkaXNjdXNzaW9uX3I5NjAzNjk4MjZcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGFycmF5XG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gc3RyaW5nfSBlbmNvZGVQYXNzYWJsZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlTGVnYWN5QXJyYXk9KGFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgY2hhcnM9WydbJ107XG5mb3IoY29uc3QgZWxlbWVudCBvZiBhcnJheSl7XG5jb25zdCBlbmM9ZW5jb2RlUGFzc2FibGUoZWxlbWVudCk7XG5mb3IoY29uc3QgYyBvZiBlbmMpe1xuaWYoYz09PSdcXHUwMDAwJ3x8Yz09PSdcXHUwMDAxJyl7XG5jaGFycy5wdXNoKCdcXHUwMDAxJyk7XG4gfVxuY2hhcnMucHVzaChjKTtcbiB9XG5jaGFycy5wdXNoKCdcXHUwMDAwJyk7XG4gfVxucmV0dXJuIGNoYXJzLmpvaW4oJycpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gUGFzc2FibGV9IGRlY29kZVBhc3NhYmxlXG4gKiBAcGFyYW0ge251bWJlcn0gW3NraXBdXG4gKiBAcmV0dXJucyB7QXJyYXl9XG4gKi9cbmNvbnN0IGRlY29kZUxlZ2FjeUFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlLHNraXA9MCk9PntcbmNvbnN0IGVsZW1lbnRzPVtdO1xuY29uc3QgZWxlbUNoYXJzPVtdO1xuLyogVXNlIGEgc3RyaW5nIGl0ZXJhdG9yIHRvIGF2b2lkIHNsb3cgaW5kZXhlZCBhY2Nlc3MgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5sZXQgc3RpbGxUb1NraXA9c2tpcCsxO1xubGV0IGluRXNjYXBlPWZhbHNlO1xuZm9yKGNvbnN0IGMgb2YgZW5jb2RlZCl7XG5pZihzdGlsbFRvU2tpcD4wKXtcbnN0aWxsVG9Ta2lwLT0xO1xuaWYoc3RpbGxUb1NraXA9PT0wKXtcbmM9PT0nWyd8fEZhaWwgYEVuY29kZWQgYXJyYXkgZXhwZWN0ZWQ6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbiB9XG4gfWVsc2UgaWYoaW5Fc2NhcGUpe1xuYz09PSdcXHUwMDAwJ3x8XG5jPT09J1xcdTAwMDEnfHxcbkZhaWwgYFVuZXhwZWN0ZWQgY2hhcmFjdGVyIGFmdGVyIHUwMDAxIGVzY2FwZTogJHtjfWA7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDAnKXtcbmNvbnN0IGVuY29kZWRFbGVtZW50PWVsZW1DaGFycy5qb2luKCcnKTtcbmVsZW1DaGFycy5sZW5ndGg9MDtcbmNvbnN0IGVsZW1lbnQ9ZGVjb2RlUGFzc2FibGUoZW5jb2RlZEVsZW1lbnQpO1xuZWxlbWVudHMucHVzaChlbGVtZW50KTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDEnKXtcbmluRXNjYXBlPXRydWU7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tY29udGludWUqL1xuY29udGludWU7XG4gfWVsc2V7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9XG5pbkVzY2FwZT1mYWxzZTtcbiB9XG4haW5Fc2NhcGV8fEZhaWwgYHVuZXhwZWN0ZWQgZW5kIG9mIGVuY29kaW5nICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmVsZW1DaGFycy5sZW5ndGg9PT0wfHxcbkZhaWwgYGVuY29kaW5nIHRlcm1pbmF0ZWQgZWFybHk6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbnJldHVybiBoYXJkZW4oZWxlbWVudHMpO1xuIH07XG5cbmNvbnN0IGVuY29kZVJlY29yZD0ocmVjb3JkLGVuY29kZUFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgbmFtZXM9cmVjb3JkTmFtZXMocmVjb3JkKTtcbmNvbnN0IHZhbHVlcz1yZWNvcmRWYWx1ZXMocmVjb3JkLG5hbWVzKTtcbnJldHVybiBgKCR7ZW5jb2RlQXJyYXkoaGFyZGVuKFtuYW1lcyx2YWx1ZXNdKSxlbmNvZGVQYXNzYWJsZSl9YDtcbiB9O1xuXG5jb25zdCBkZWNvZGVSZWNvcmQ9KGVuY29kZWQsZGVjb2RlQXJyYXksZGVjb2RlUGFzc2FibGUsc2tpcD0wKT0+e1xuYXNzZXJ0KGVuY29kZWQuY2hhckF0KHNraXApPT09JygnKTtcbi8qIFNraXAgdGhlIFwiKFwiIGluc2lkZSBgZGVjb2RlQXJyYXlgIHRvIGF2b2lkIHNsb3cgYHN1YnN0cmluZ2AgaW4gWFMuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTk4NCovXG5jb25zdCB1bnppcHBlZEVudHJpZXM9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudW56aXBwZWRFbnRyaWVzLmxlbmd0aD09PTJ8fFxuRmFpbCBgZXhwZWN0ZWQga2V5cyx2YWx1ZXMgcGFpcjogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xuY29uc3Rba2V5cyx2YWxzXT11bnppcHBlZEVudHJpZXM7XG5cbnBhc3NTdHlsZU9mKGtleXMpPT09J2NvcHlBcnJheScmJlxucGFzc1N0eWxlT2YodmFscyk9PT0nY29weUFycmF5JyYmXG5rZXlzLmxlbmd0aD09PXZhbHMubGVuZ3RoJiZcbmtleXMuZXZlcnkoKGtleSk9PnR5cGVvZiBrZXk9PT0nc3RyaW5nJyl8fFxuRmFpbCBgbm90IGEgdmFsaWQgcmVjb3JkIGVuY29kaW5nOiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG5jb25zdCBtYXBFbnRyaWVzPWtleXMubWFwKChrZXksaSk9PltrZXksdmFsc1tpXV0pO1xuY29uc3QgcmVjb3JkPWhhcmRlbihmcm9tRW50cmllcyhtYXBFbnRyaWVzKSk7XG5hc3NlcnRSZWNvcmQocmVjb3JkLCdkZWNvZGVkIHJlY29yZCcpO1xucmV0dXJuIHJlY29yZDtcbiB9O1xuXG5jb25zdCBlbmNvZGVUYWdnZWQ9KHRhZ2dlZCxlbmNvZGVBcnJheSxlbmNvZGVQYXNzYWJsZSk9PlxuIGA6JHtlbmNvZGVBcnJheShoYXJkZW4oW2dldFRhZyh0YWdnZWQpLHRhZ2dlZC5wYXlsb2FkXSksZW5jb2RlUGFzc2FibGUpfWA7XG5cbmNvbnN0IGRlY29kZVRhZ2dlZD0oZW5jb2RlZCxkZWNvZGVBcnJheSxkZWNvZGVQYXNzYWJsZSxza2lwPTApPT57XG5hc3NlcnQoZW5jb2RlZC5jaGFyQXQoc2tpcCk9PT0nOicpO1xuLyogU2tpcCB0aGUgXCI6XCIgaW5zaWRlIGBkZWNvZGVBcnJheWAgdG8gYXZvaWQgc2xvdyBgc3Vic3RyaW5nYCBpbiBYUy4qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xOTg0Ki9cbmNvbnN0IHRhZ2dlZFBheWxvYWQ9ZGVjb2RlQXJyYXkoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSxza2lwKzEpO1xudGFnZ2VkUGF5bG9hZC5sZW5ndGg9PT0yfHxcbkZhaWwgYGV4cGVjdGVkIHRhZyxwYXlsb2FkIHBhaXI6ICR7Z2V0U3VmZml4KGVuY29kZWQsc2tpcCl9YDtcbmNvbnN0W3RhZyxwYXlsb2FkXT10YWdnZWRQYXlsb2FkO1xucGFzc1N0eWxlT2YodGFnKT09PSdzdHJpbmcnfHxcbkZhaWwgYG5vdCBhIHZhbGlkIHRhZ2dlZCBlbmNvZGluZzogJHtnZXRTdWZmaXgoZW5jb2RlZCxza2lwKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLHBheWxvYWQpO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVSZW1vdGFibGU9KHVuc2FmZUVuY29kZVJlbW90YWJsZSx2ZXJpZnlFbmNvZGluZyk9PntcbmNvbnN0IGVuY29kZVJlbW90YWJsZT0ocixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVJlbW90YWJsZShyLGlubmVyRW5jb2RlKTtcbnR5cGVvZiBlbmNvZGluZz09PSdzdHJpbmcnJiZlbmNvZGluZy5jaGFyQXQoMCk9PT0ncid8fFxuRmFpbCBgUmVtb3RhYmxlIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcInJcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ1JlbW90YWJsZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUmVtb3RhYmxlO1xuIH07XG5cbmNvbnN0IG1ha2VFbmNvZGVQcm9taXNlPSh1bnNhZmVFbmNvZGVQcm9taXNlLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlUHJvbWlzZT0ocCxpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZVByb21pc2UocCxpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09Jz8nfHxcbkZhaWwgYFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiP1wiOiAke2VuY29kaW5nfWA7XG52ZXJpZnlFbmNvZGluZyhlbmNvZGluZywnUHJvbWlzZScpO1xucmV0dXJuIGVuY29kaW5nO1xuIH07XG5yZXR1cm4gZW5jb2RlUHJvbWlzZTtcbiB9O1xuXG5jb25zdCBtYWtlRW5jb2RlRXJyb3I9KHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKT0+e1xuY29uc3QgZW5jb2RlRXJyb3I9KGVycixpbm5lckVuY29kZSk9PntcbmNvbnN0IGVuY29kaW5nPXVuc2FmZUVuY29kZUVycm9yKGVycixpbm5lckVuY29kZSk7XG50eXBlb2YgZW5jb2Rpbmc9PT0nc3RyaW5nJyYmZW5jb2RpbmcuY2hhckF0KDApPT09JyEnfHxcbkZhaWwgYEVycm9yIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcIiFcIjogJHtlbmNvZGluZ31gO1xudmVyaWZ5RW5jb2RpbmcoZW5jb2RpbmcsJ0Vycm9yJyk7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfTtcbnJldHVybiBlbmNvZGVFcnJvcjtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVSZW1vdGFibGVdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVQcm9taXNlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVFcnJvcl1cbiAqIEBwcm9wZXJ0eSB7J2xlZ2FjeU9yZGVyZWQnIHwgJ2NvbXBhY3RPcmRlcmVkJ30gW2Zvcm1hdF1cbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7KHN0cjogc3RyaW5nKSA9PiBzdHJpbmd9IGVuY29kZVN0cmluZ1N1ZmZpeFxuICogQHBhcmFtIHsoYXJyOiB1bmtub3duW10sIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZykgPT4gc3RyaW5nfSBlbmNvZGVBcnJheVxuICogQHBhcmFtIHtSZXF1aXJlZDxFbmNvZGVPcHRpb25zPiAmIHt2ZXJpZnlFbmNvZGluZz86IChlbmNvZGVkOiBzdHJpbmcsIGxhYmVsOiBzdHJpbmcpID0+IHZvaWR9fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KHA6IFBhc3NhYmxlKSA9PiBzdHJpbmd9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckVuY29kZT0oZW5jb2RlU3RyaW5nU3VmZml4LGVuY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZTp1bnNhZmVFbmNvZGVSZW1vdGFibGUsXG5lbmNvZGVQcm9taXNlOnVuc2FmZUVuY29kZVByb21pc2UsXG5lbmNvZGVFcnJvcjp1bnNhZmVFbmNvZGVFcnJvcixcbnZlcmlmeUVuY29kaW5nPSgpPT57IH19PVxub3B0aW9ucztcbmNvbnN0IGVuY29kZVJlbW90YWJsZT1tYWtlRW5jb2RlUmVtb3RhYmxlKFxudW5zYWZlRW5jb2RlUmVtb3RhYmxlLFxudmVyaWZ5RW5jb2RpbmcpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlPW1ha2VFbmNvZGVQcm9taXNlKHVuc2FmZUVuY29kZVByb21pc2UsdmVyaWZ5RW5jb2RpbmcpO1xuY29uc3QgZW5jb2RlRXJyb3I9bWFrZUVuY29kZUVycm9yKHVuc2FmZUVuY29kZUVycm9yLHZlcmlmeUVuY29kaW5nKTtcblxuY29uc3QgaW5uZXJFbmNvZGU9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gZW5jb2RlRXJyb3IocGFzc2FibGUsaW5uZXJFbmNvZGUpO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXNzYWJsZSk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnbnVsbCc6e1xucmV0dXJuJ3YnO1xuIH1cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm4neic7XG4gfVxuY2FzZSdudW1iZXInOntcbnJldHVybiBlbmNvZGVCaW5hcnk2NChwYXNzYWJsZSk7XG4gfVxuY2FzZSdzdHJpbmcnOntcbnJldHVybiBgcyR7ZW5jb2RlU3RyaW5nU3VmZml4KHBhc3NhYmxlKX1gO1xuIH1cbmNhc2UnYm9vbGVhbic6e1xucmV0dXJuIGBiJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gZW5jb2RlQmlnSW50KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xucmV0dXJuIGVuY29kZVJlbW90YWJsZShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIGVuY29kZUVycm9yKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBlbmNvZGVQcm9taXNlKHBhc3NhYmxlLGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuLyogU3RyaW5ncyBhbmQgc3ltYm9scyBzaGFyZSBlbmNvZGluZyBsb2dpYy4qL1xuY29uc3QgbmFtZT1uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbnJldHVybiBgeSR7ZW5jb2RlU3RyaW5nU3VmZml4KG5hbWUpfWA7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbnJldHVybiBlbmNvZGVBcnJheShwYXNzYWJsZSxpbm5lckVuY29kZSk7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG5yZXR1cm4gZW5jb2RlUmVjb3JkKHBhc3NhYmxlLGVuY29kZUFycmF5LGlubmVyRW5jb2RlKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJuIGVuY29kZVRhZ2dlZChwYXNzYWJsZSxlbmNvZGVBcnJheSxpbm5lckVuY29kZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBhICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgdXNlZCBhcyBhIGNvbGxlY3Rpb24gcGFzc2FibGVgO1xuIH19XG5cbiB9O1xucmV0dXJuIGlubmVyRW5jb2RlO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yXVxuICovXG5cbmNvbnN0IGxpYmVyYWxEZWNvZGVycz0vKiogQHR5cGUge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSAqL1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL3tcbmRlY29kZVJlbW90YWJsZTooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZCxcbmRlY29kZVByb21pc2U6KF9lbmNvZGluZyxfaW5uZXJEZWNvZGUpPT51bmRlZmluZWQsXG5kZWNvZGVFcnJvcjooX2VuY29kaW5nLF9pbm5lckRlY29kZSk9PnVuZGVmaW5lZH07XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gc3RyaW5nfSBkZWNvZGVTdHJpbmdTdWZmaXhcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZywgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlLCBza2lwPzogbnVtYmVyKSA9PiB1bmtub3duW119IGRlY29kZUFycmF5XG4gKiBAcGFyYW0ge1JlcXVpcmVkPERlY29kZU9wdGlvbnM+fSBvcHRpb25zXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0IG1ha2VJbm5lckRlY29kZT0oZGVjb2RlU3RyaW5nU3VmZml4LGRlY29kZUFycmF5LG9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVSZW1vdGFibGUsZGVjb2RlUHJvbWlzZSxkZWNvZGVFcnJvcn09b3B0aW9ucztcbi8qKiBAdHlwZSB7KGVuY29kZWQ6IHN0cmluZywgc2tpcD86IG51bWJlcikgPT4gUGFzc2FibGV9ICovXG5jb25zdCBpbm5lckRlY29kZT0oZW5jb2RlZCxza2lwPTApPT57XG5zd2l0Y2goZW5jb2RlZC5jaGFyQXQoc2tpcCkpe1xuY2FzZSd2Jzp7XG5yZXR1cm4gbnVsbDtcbiB9XG5jYXNlJ3onOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdmJzp7XG5yZXR1cm4gZGVjb2RlQmluYXJ5NjQoZW5jb2RlZCxza2lwKTtcbiB9XG5jYXNlJ3MnOntcbnJldHVybiBkZWNvZGVTdHJpbmdTdWZmaXgoZ2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKSk7XG4gfVxuY2FzZSdiJzp7XG5jb25zdCBzdWJzdHJpbmc9Z2V0U3VmZml4KGVuY29kZWQsc2tpcCsxKTtcbmlmKHN1YnN0cmluZz09PSd0cnVlJyl7XG5yZXR1cm4gdHJ1ZTtcbiB9ZWxzZSBpZihzdWJzdHJpbmc9PT0nZmFsc2UnKXtcbnJldHVybiBmYWxzZTtcbiB9XG50aHJvdyBGYWlsIGBleHBlY3RlZCBlbmNvZGVkIGJvb2xlYW4gdG8gYmUgXCJidHJ1ZVwiIG9yIFwiYmZhbHNlXCI6ICR7c3Vic3RyaW5nfWA7XG4gfVxuY2FzZSduJzpcbmNhc2UncCc6e1xucmV0dXJuIGRlY29kZUJpZ0ludChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSk7XG4gfVxuY2FzZSdyJzp7XG5yZXR1cm4gZGVjb2RlUmVtb3RhYmxlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJz8nOntcbnJldHVybiBkZWNvZGVQcm9taXNlKGdldFN1ZmZpeChlbmNvZGVkLHNraXApLGlubmVyRGVjb2RlKTtcbiB9XG5jYXNlJyEnOntcbnJldHVybiBkZWNvZGVFcnJvcihnZXRTdWZmaXgoZW5jb2RlZCxza2lwKSxpbm5lckRlY29kZSk7XG4gfVxuY2FzZSd5Jzp7XG4vKiBTdHJpbmdzIGFuZCBzeW1ib2xzIHNoYXJlIGRlY29kaW5nIGxvZ2ljLiovXG5jb25zdCBuYW1lPWRlY29kZVN0cmluZ1N1ZmZpeChnZXRTdWZmaXgoZW5jb2RlZCxza2lwKzEpKTtcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG4gfVxuY2FzZSdbJzpcbmNhc2UnXic6e1xuLyogQHRzLWV4cGVjdC1lcnJvciBUeXBlICd1bmtub3duW10nIGlzIG5vdCBQYXNzYWJsZSovXG5yZXR1cm4gZGVjb2RlQXJyYXkoZW5jb2RlZCxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJygnOntcbnJldHVybiBkZWNvZGVSZWNvcmQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5jYXNlJzonOntcbnJldHVybiBkZWNvZGVUYWdnZWQoZW5jb2RlZCxkZWNvZGVBcnJheSxpbm5lckRlY29kZSxza2lwKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYGludmFsaWQgZGF0YWJhc2Uga2V5OiAke2dldFN1ZmZpeChlbmNvZGVkLHNraXApfWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaW5uZXJEZWNvZGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXNzYWJsZUtpdFxuICogQHByb3BlcnR5IHtSZXR1cm5UeXBlPG1ha2VJbm5lckVuY29kZT59IGVuY29kZVBhc3NhYmxlXG4gKiBAcHJvcGVydHkge1JldHVyblR5cGU8bWFrZUlubmVyRGVjb2RlPn0gZGVjb2RlUGFzc2FibGVcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlT3B0aW9ucyAmIERlY29kZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhc3NhYmxlS2l0PShvcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGU9KHIsXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3J9YCxcbmVuY29kZVByb21pc2U9KHAsXyk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwfWAsXG5lbmNvZGVFcnJvcj0oZXJyLF8pPT5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke2Vycn1gLFxuZm9ybWF0PSdsZWdhY3lPcmRlcmVkJyxcblxuZGVjb2RlUmVtb3RhYmxlPShlbmNvZGluZyxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZVByb21pc2U9KGVuY29kaW5nLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YCxcbmRlY29kZUVycm9yPShlbmNvZGluZyxfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gfT1cbm9wdGlvbnM7XG5cbi8qKiBAdHlwZSB7UGFzc2FibGVLaXRbJ2VuY29kZVBhc3NhYmxlJ119ICovXG5sZXQgZW5jb2RlUGFzc2FibGU7XG5jb25zdCBlbmNvZGVPcHRpb25zPXtlbmNvZGVSZW1vdGFibGUsZW5jb2RlUHJvbWlzZSxlbmNvZGVFcnJvcixmb3JtYXR9O1xuaWYoZm9ybWF0PT09J2NvbXBhY3RPcmRlcmVkJyl7XG5jb25zdCBsaWJlcmFsRGVjb2RlPW1ha2VJbm5lckRlY29kZShcbmRlY29kZUNvbXBhY3RTdHJpbmdTdWZmaXgsXG5kZWNvZGVDb21wYWN0QXJyYXksXG5saWJlcmFsRGVjb2RlcnMpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGluZ1xuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgdmVyaWZ5RW5jb2Rpbmc9KGVuY29kaW5nLGxhYmVsKT0+e1xuIWVuY29kaW5nLm1hdGNoKHJDMCl8fFxuRmFpbCBgJHtiKFxubGFiZWwpXG4gfSBlbmNvZGluZyBtdXN0IG5vdCBjb250YWluIGEgQzAgY29udHJvbCBjaGFyYWN0ZXI6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRlY29kZWQ9ZGVjb2RlQ29tcGFjdEFycmF5KCBgXnYgJHtlbmNvZGluZ30gdiBgLGxpYmVyYWxEZWNvZGUpO1xuaXNBcnJheShkZWNvZGVkKSYmXG5kZWNvZGVkLmxlbmd0aD09PTMmJlxuZGVjb2RlZFswXT09PW51bGwmJlxuZGVjb2RlZFsyXT09PW51bGx8fFxuRmFpbCBgJHtiKGxhYmVsKX0gZW5jb2RpbmcgbXVzdCBiZSBlbWJlZGRhYmxlOiAke2VuY29kaW5nfWA7XG4gfTtcbmNvbnN0IGVuY29kZUNvbXBhY3Q9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmVuY29kZUNvbXBhY3RBcnJheSxcbnsuLi5lbmNvZGVPcHRpb25zLHZlcmlmeUVuY29kaW5nfSk7XG5cbmVuY29kZVBhc3NhYmxlPShwYXNzYWJsZSk9PiBgfiR7ZW5jb2RlQ29tcGFjdChwYXNzYWJsZSl9YDtcbiB9ZWxzZSBpZihmb3JtYXQ9PT0nbGVnYWN5T3JkZXJlZCcpe1xuZW5jb2RlUGFzc2FibGU9bWFrZUlubmVyRW5jb2RlKFxuZW5jb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZW5jb2RlTGVnYWN5QXJyYXksXG5lbmNvZGVPcHRpb25zKTtcblxuIH1lbHNle1xudGhyb3cgRmFpbCBgVW5yZWNvZ25pemVkIGZvcm1hdDogJHtxKGZvcm1hdCl9YDtcbiB9XG5cbmNvbnN0IGRlY29kZU9wdGlvbnM9e2RlY29kZVJlbW90YWJsZSxkZWNvZGVQcm9taXNlLGRlY29kZUVycm9yfTtcbmNvbnN0IGRlY29kZUNvbXBhY3Q9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlQ29tcGFjdFN0cmluZ1N1ZmZpeCxcbmRlY29kZUNvbXBhY3RBcnJheSxcbmRlY29kZU9wdGlvbnMpO1xuXG5jb25zdCBkZWNvZGVMZWdhY3k9bWFrZUlubmVyRGVjb2RlKFxuZGVjb2RlTGVnYWN5U3RyaW5nU3VmZml4LFxuZGVjb2RlTGVnYWN5QXJyYXksXG5kZWNvZGVPcHRpb25zKTtcblxuY29uc3QgZGVjb2RlUGFzc2FibGU9KGVuY29kZWQpPT57XG4vKiBBIGxlYWRpbmcgXCJ+XCIgaW5kaWNhdGVzIHRoZSB2MiBlbmNvZGluZyAod2l0aCBlc2NhcGluZyBpbiBzdHJpbmdzIHJhdGhlciB0aGFuIGFycmF5cykuKi9cbi8qIFNraXAgaXQgaW5zaWRlIGBkZWNvZGVDb21wYWN0YCB0byBhdm9pZCBzbG93IGBzdWJzdHJpbmdgIGluIFhTLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE5ODQqL1xuaWYoZW5jb2RlZC5jaGFyQXQoMCk9PT0nficpe1xucmV0dXJuIGRlY29kZUNvbXBhY3QoZW5jb2RlZCwxKTtcbiB9XG5yZXR1cm4gZGVjb2RlTGVnYWN5KGVuY29kZWQpO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe2VuY29kZVBhc3NhYmxlLGRlY29kZVBhc3NhYmxlfSk7XG4gfTskaM2PX29uY2UubWFrZVBhc3NhYmxlS2l0KG1ha2VQYXNzYWJsZUtpdCk7XG5oYXJkZW4obWFrZVBhc3NhYmxlS2l0KTtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMge1Bhc3NhYmxlS2l0WydlbmNvZGVQYXNzYWJsZSddfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVBhc3NhYmxlPShlbmNvZGVPcHRpb25zKT0+e1xuY29uc3R7ZW5jb2RlUGFzc2FibGV9PW1ha2VQYXNzYWJsZUtpdChlbmNvZGVPcHRpb25zKTtcbnJldHVybiBlbmNvZGVQYXNzYWJsZTtcbiB9OyRozY9fb25jZS5tYWtlRW5jb2RlUGFzc2FibGUobWFrZUVuY29kZVBhc3NhYmxlKTtcbmhhcmRlbihtYWtlRW5jb2RlUGFzc2FibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7RGVjb2RlT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7UGFzc2FibGVLaXRbJ2RlY29kZVBhc3NhYmxlJ119XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlUGFzc2FibGU9KGRlY29kZU9wdGlvbnMpPT57XG5jb25zdHtkZWNvZGVQYXNzYWJsZX09bWFrZVBhc3NhYmxlS2l0KGRlY29kZU9wdGlvbnMpO1xucmV0dXJuIGRlY29kZVBhc3NhYmxlO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVQYXNzYWJsZShtYWtlRGVjb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5cbmNvbnN0ICAgICAgICBpc0VuY29kZWRSZW1vdGFibGU9KGVuY29kZWQpPT5lbmNvZGVkLmNoYXJBdCgwKT09PSdyJzskaM2PX29uY2UuaXNFbmNvZGVkUmVtb3RhYmxlKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5oYXJkZW4oaXNFbmNvZGVkUmVtb3RhYmxlKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlIHtSZWNvcmQ8UGFzc1N0eWxlLCBzdHJpbmc+fVxuICogVGhlIHNpbmdsZSBwcmVmaXggY2hhcmFjdGVycyB0byBiZSB1c2VkIGZvciBlYWNoIFBhc3NTdHlsZSBjYXRlZ29yeS5cbiAqIGBiaWdpbnRgIGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBlYWNoIG9mIHRob3NlIGNoYXJhY3RlcnNcbiAqIGluZGl2aWR1YWxseSBpcyBhIHZhbGlkIGJpZ2ludCBwcmVmaXggKGBuYCBmb3IgXCJuZWdhdGl2ZVwiIGFuZCBgcGAgZm9yXG4gKiBcInBvc2l0aXZlXCIpLCBhbmQgY29weUFycmF5IGlzIGEgdHdvLWNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBvbmUgZW5jb2RpbmdcbiAqIHByZWZpeGVzIGFycmF5cyB3aXRoIGBbYCB3aGlsZSB0aGUgb3RoZXIgdXNlcyBgXmAgKHdoaWNoIGlzIHByb2hpYml0ZWQgZnJvbVxuICogYXBwZWFyaW5nIGluIGFuIGVuY29kZWQgc3RyaW5nKS5cbiAqIFRoZSBvcmRlcmluZyBvZiB0aGVzZSBwcmVmaXhlcyBpcyB0aGUgc2FtZSBhcyB0aGUgcmFua09yZGVyaW5nIG9mIHRoZWlyXG4gKiByZXNwZWN0aXZlIFBhc3NTdHlsZXMsIGFuZCByYW5rT3JkZXIuanMgaW1wb3J0cyB0aGUgdGFibGUgZm9yIHRoaXMgcHVycG9zZS5cbiAqXG4gKiBJbiBhZGRpdGlvbiwgYHxgIGlzIHRoZSByZW1vdGFibGUtPm9yZGluYWwgbWFwcGluZyBwcmVmaXg6XG4gKiBUaGlzIGlzIG5vdCB1c2VkIGluIGNvdmVycyBidXQgaXQgaXNcbiAqIHJlc2VydmVkIGZyb20gdGhlIHNhbWUgc2V0IG9mIHN0cmluZ3MuIE5vdGUgdGhhdCB0aGUgcHJlZml4IGlzID4gYW55XG4gKiBwcmVmaXggdXNlZCBieSBhbnkgY292ZXIgc28gdGhhdCBvcmRpbmFsIG1hcHBpbmcga2V5cyBhcmUgYWx3YXlzIG91dHNpZGVcbiAqIHRoZSByYW5nZSBvZiB2YWxpZCBjb2xsZWN0aW9uIGVudHJ5IGtleXMuXG4gKi9cbmNvbnN0ICAgICAgICBwYXNzU3R5bGVQcmVmaXhlcz17XG5lcnJvcjonIScsXG5jb3B5UmVjb3JkOicoJyxcbnRhZ2dlZDonOicsXG5wcm9taXNlOic/JyxcbmNvcHlBcnJheTonW14nLFxuYm9vbGVhbjonYicsXG5udW1iZXI6J2YnLFxuYmlnaW50OiducCcsXG5yZW1vdGFibGU6J3InLFxuc3RyaW5nOidzJyxcbm51bGw6J3YnLFxuc3ltYm9sOid5Jyxcbi8qIEJlY2F1c2UgQXJyYXkucHJvdG90eXBlLnNvcnQgcHV0cyB1bmRlZmluZWQgdmFsdWVzIGF0IHRoZSBlbmQgd2l0aG91dCovXG4vKiBwYXNzaW5nIHRoZW0gdG8gYSBjb21wYXJpc29uIGZ1bmN0aW9uLCB1bmRlZmluZWQgTVVTVCBiZSB0aGUgbGFzdCovXG4vKiBjYXRlZ29yeS4qL1xudW5kZWZpbmVkOid6J307JGjNj19vbmNlLnBhc3NTdHlsZVByZWZpeGVzKHBhc3NTdHlsZVByZWZpeGVzKTtcblxuT2JqZWN0LnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVByZWZpeGVzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVByZWZpeGVzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InJlY29yZE5hbWVzIjpbInJlY29yZE5hbWVzIl0sInJlY29yZFZhbHVlcyI6WyJyZWNvcmRWYWx1ZXMiXSwiemVyb1BhZCI6WyJ6ZXJvUGFkIl0sIm1ha2VQYXNzYWJsZUtpdCI6WyJtYWtlUGFzc2FibGVLaXQiXSwibWFrZUVuY29kZVBhc3NhYmxlIjpbIm1ha2VFbmNvZGVQYXNzYWJsZSJdLCJtYWtlRGVjb2RlUGFzc2FibGUiOlsibWFrZURlY29kZVBhc3NhYmxlIl0sImlzRW5jb2RlZFJlbW90YWJsZSI6WyJpc0VuY29kZWRSZW1vdGFibGUiXSwicGFzc1N0eWxlUHJlZml4ZXMiOlsicGFzc1N0eWxlUHJlZml4ZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAMYqu5Eo6AABKOgAAKwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9lbmNvZGVUb0NhcERhdGEuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIlFDTEFTUyIsIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSIsIm1ha2VFbmNvZGVUb0NhcERhdGEiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxpc09iamVjdCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lLFgsRmFpbCxxOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRozY9fYSA9PiAocGFzc1N0eWxlT2YgPSAkaM2PX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRozY9fYSA9PiAoaXNFcnJvckxpa2UgPSAkaM2PX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjNj19hID0+IChtYWtlVGFnZ2VkID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImdldFRhZ1wiLCBbJGjNj19hID0+IChnZXRUYWcgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaM2PX2EgPT4gKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzYWJsZSwgUmVtb3RhYmxlT2JqZWN0fSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuLyoqIEBpbXBvcnQge0VuY29kaW5nLCBFbmNvZGluZ1VuaW9ufSBmcm9tICcuL3R5cGVzLmpzJyAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsXG5kZWZpbmVQcm9wZXJ0aWVzLFxuaXMsXG5lbnRyaWVzLFxuZnJvbUVudHJpZXMsXG5mcmVlemV9PVxuT2JqZWN0O1xuXG4vKipcbiAqIFNwZWNpYWwgcHJvcGVydHkgbmFtZSB0aGF0IGluZGljYXRlcyBhbiBlbmNvZGluZyB0aGF0IG5lZWRzIHNwZWNpYWxcbiAqIGRlY29kaW5nLlxuICovXG5jb25zdCBRQ0xBU1M9J0BxY2xhc3MnOyRozY9fb25jZS5RQ0xBU1MoUUNMQVNTKTtcblxuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEByZXR1cm5zIHtlbmNvZGVkIGlzIEVuY29kaW5nVW5pb259XG4gKi9cbmNvbnN0IGhhc1FDbGFzcz0oZW5jb2RlZCk9Pmhhc093blByb3BlcnR5T2YoZW5jb2RlZCxRQ0xBU1MpO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7c3RyaW5nfSBxY2xhc3NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBxY2xhc3NNYXRjaGVzPShlbmNvZGVkLHFjbGFzcyk9PlxuaXNPYmplY3QoZW5jb2RlZCkmJlxuIWlzQXJyYXkoZW5jb2RlZCkmJlxuaGFzUUNsYXNzKGVuY29kZWQpJiZcbmVuY29kZWRbUUNMQVNTXT09PXFjbGFzcztcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVUb0NhcERhdGFPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGVPYmplY3QsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IEVuY29kaW5nXG4gKiApID0+IEVuY29kaW5nfSBbZW5jb2RlRXJyb3JUb0NhcERhdGFdXG4gKi9cblxuY29uc3QgZG9udEVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT0ocmVtKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9tKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YDtcblxuY29uc3QgZG9udEVuY29kZUVycm9yVG9DYXBEYXRhPShlcnIpPT5GYWlsIGBlcnJvciBvYmplY3QgdW5leHBlY3RlZDogJHtlcnJ9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZVRvQ2FwRGF0YU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IEVuY29kaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVRvQ2FwRGF0YT0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhPWRvbnRFbmNvZGVSZW1vdGFibGVUb0NhcERhdGEsXG5lbmNvZGVQcm9taXNlVG9DYXBEYXRhPWRvbnRFbmNvZGVQcm9taXNlVG9DYXBEYXRhLFxuZW5jb2RlRXJyb3JUb0NhcERhdGE9ZG9udEVuY29kZUVycm9yVG9DYXBEYXRhfT1cbmVuY29kZU9wdGlvbnM7XG5cbi8qKlxuICogTXVzdCBlbmNvZGUgYHZhbGAgaW50byBwbGFpbiBKU09OIGRhdGEgKmNhbm9uaWNhbGx5Kiwgc3VjaCB0aGF0XG4gKiBgSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSkgPT09IEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpYC4gRm9yIG1vc3RcbiAqIGVuY29kaW5ncywgdGhlIG9yZGVyIG9mIHByb3BlcnRpZXMgb2YgZWFjaCBub2RlIG9mIHRoZSBvdXRwdXRcbiAqIHN0cnVjdHVyZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhbGdvcml0aG0gYmVsb3cgd2l0aG91dCBzcGVjaWFsXG4gKiBhcnJhbmdlbWVudCwgdXN1YWxseSBieSBiZWluZyBleHByZXNzZWQgZGlyZWN0bHkgYXMgYW4gb2JqZWN0IGxpdGVyYWwuXG4gKiBUaGUgZXhjZXB0aW9uIGlzIGNvcHlSZWNvcmRzLCB3aG9zZSBuYXR1cmFsIGVudW1lcmF0aW9uIG9yZGVyXG4gKiBjYW4gZGlmZmVyIGJldHdlZW4gY29weVJlY29yZHMgdGhhdCBvdXIgZGlzdHJpYnV0ZWQgb2JqZWN0IHNlbWFudGljc1xuICogY29uc2lkZXJzIHRvIGJlIGVxdWl2YWxlbnQuXG4gKiBTaW5jZSwgZm9yIGVhY2ggY29weVJlY29yZCwgd2Ugb25seSBhY2NlcHQgc3RyaW5nIHByb3BlcnR5IG5hbWVzLFxuICogbm90IHN5bWJvbHMsIHdlIGNhbiBjYW5vbmljYWxseSBzb3J0IHRoZSBuYW1lcyBmaXJzdC5cbiAqIEpTT04uc3RyaW5naWZ5IHdpbGwgdGhlbiB2aXNpdCB0aGVzZSBpbiB0aGF0IHNvcnRlZCBvcmRlci5cbiAqXG4gKiBFbmNvZGluZyB3aXRoIGEgY2Fub25pY2FsLUpTT04gZW5jb2RlciB3b3VsZCBhbHNvIHNvbHZlIHRoaXMgY2Fub25pY2FsbmVzc1xuICogcHJvYmxlbSBpbiBhIG1vcmUgbW9kdWxhciBhbmQgZW5jYXBzdWxhdGVkIG1hbm5lci4gTm90ZSB0aGF0IHRoZVxuICogYWN0dWFsIG9yZGVyIHByb2R1Y2VkIGhlcmUsIHRob3VnaCBpdCBhZ3JlZXMgd2l0aCBjYW5vbmljYWwtSlNPTiBvblxuICogY29weVJlY29yZCBwcm9wZXJ0eSBvcmRlcmluZywgZGlmZmVycyBmcm9tIGNhbm9uaWNhbC1KU09OIGFzIGEgd2hvbGVcbiAqIGluIHRoYXQgdGhlIG90aGVyIHJlY29yZCBwcm9wZXJ0aWVzIGFyZSB2aXNpdGVkIGluIHRoZSBvcmRlciBpbiB3aGljaFxuICogdGhleSBhcmUgbGl0ZXJhbGx5IHdyaXR0ZW4gYmVsb3cuIFRPRE8gcGVyaGFwcyB3ZSBzaG91bGQgaW5kZWVkIHN3aXRjaFxuICogdG8gYSBjYW5vbmljYWwgSlNPTiBlbmNvZGVyLCBhbmQgbm90IGRlbGljYXRlbHkgZGVwZW5kIG9uIHRoZSBvcmRlclxuICogaW4gd2hpY2ggdGhlc2Ugb2JqZWN0IGxpdGVyYWxzIGFyZSB3cml0dGVuLlxuICpcbiAqIFJlYWRlcnMgbXVzdCBub3QgY2FyZSBhYm91dCB0aGlzIG9yZGVyIGFueXdheS4gV2UgaW1wb3NlIHRoaXMgcmVxdWlyZW1lbnRcbiAqIG1haW5seSB0byByZWR1Y2Ugbm9uLWRldGVybWluaXNtIGV4cG9zZWQgb3V0c2lkZSBhIHZhdC5cbiAqXG4gKiBAcGFyYW0ge2FueX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHtFbmNvZGluZ30gZXhjZXB0IHRoYXQgYGVuY29kZVRvQ2FwRGF0YWAgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb0NhcERhdGFgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb0NhcERhdGFSZWN1cj0ocGFzc2FibGUpPT57XG4vKiBGaXJzdCB3ZSBoYW5kbGUgYWxsIHByaW1pdGl2ZXMuIFNvbWUgY2FuIGJlIHJlcHJlc2VudGVkIGRpcmVjdGx5IGFzKi9cbi8qIEpTT04sIGFuZCBzb21lIG11c3QgYmUgZW5jb2RlZCBhcyBbUUNMQVNTXSBjb21wb3NpdGVzLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybntbUUNMQVNTXTondW5kZWZpbmVkJ307XG4gfVxuY2FzZSdudW1iZXInOntcbi8qIFNwZWNpYWwtY2FzZSBudW1iZXJzIHdpdGggbm8gZGlnaXQtYmFzZWQgcmVwcmVzZW50YXRpb24uKi9cbmlmKE51bWJlci5pc05hTihwYXNzYWJsZSkpe1xucmV0dXJue1tRQ0xBU1NdOidOYU4nfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybntbUUNMQVNTXTonSW5maW5pdHknfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106Jy1JbmZpbml0eSd9O1xuIH1cbi8qIFBhc3MgdGhyb3VnaCBldmVyeXRoaW5nIGVsc2UsIHJlcGxhY2luZyAtMCB3aXRoIDAuKi9cbnJldHVybiBpcyhwYXNzYWJsZSwtMCk/MDpwYXNzYWJsZTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJue1xuW1FDTEFTU106J2JpZ2ludCcsXG5kaWdpdHM6U3RyaW5nKHBhc3NhYmxlKX07XG5cbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJue1xuW1FDTEFTU106J3N5bWJvbCcsXG5uYW1lfTtcblxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaGFzT3duUHJvcGVydHlPZihwYXNzYWJsZSxRQ0xBU1MpKXtcbi8qIEhpbGJlcnQgaG90ZWwqL1xuY29uc3R7W1FDTEFTU106cWNsYXNzVmFsdWUsLi4ucmVzdH09cGFzc2FibGU7XG4vKiogQHR5cGUge0VuY29kaW5nfSAqL1xuY29uc3QgcmVzdWx0PXtcbltRQ0xBU1NdOidoaWxiZXJ0Jyxcbm9yaWdpbmFsOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHFjbGFzc1ZhbHVlKX07XG5cbmlmKG93bktleXMocmVzdCkubGVuZ3RoPj0xKXtcbi8qIFdlIGhhcmRlbiB0aGUgZW50aXJlIGNhcERhdGEgZW5jb2RpbmcgYmVmb3JlIHdlIHJldHVybiBpdC4qL1xuLyogYGVuY29kZVRvQ2FwRGF0YWAgcmVxdWlyZXMgdGhhdCBpdHMgaW5wdXQgYmUgUGFzc2FibGUsIGFuZCovXG4vKiB0aGVyZWZvcmUgaGFyZGVuZWQuKi9cbi8qIFRoZSBgZnJlZXplYCBoZXJlIGlzIG5lZWRlZCBhbnl3YXksIGJlY2F1c2UgdGhlIGByZXN0YCBpcyovXG4vKiBmcmVzaGx5IGNvbnN0cnVjdGVkIGJ5IHRoZSBgLi4uYCBhYm92ZSwgYW5kIHdlJ3JlIHVzaW5nIGl0Ki9cbi8qIGFzIGltcHV0IGluIGFub3RoZXIgY2FsbCB0byBgZW5jb2RlVG9DYXBEYXRhYC4qL1xucmVzdWx0LnJlc3Q9ZW5jb2RlVG9DYXBEYXRhUmVjdXIoZnJlZXplKHJlc3QpKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEN1cnJlbnRseSBjb3B5UmVjb3JkIGFsbG93cyBvbmx5IHN0cmluZyBrZXlzIHNvIHRoaXMgd2lsbCovXG4vKiB3b3JrLiBJZiB3ZSBhbGxvdyBzb3J0YWJsZSBzeW1ib2wga2V5cywgdGhpcyB3aWxsIG5lZWQgdG8qL1xuLyogYmVjb21lIG1vcmUgaW50ZXJlc3RpbmcuKi9cbmNvbnN0IG5hbWVzPW93bktleXMocGFzc2FibGUpLnNvcnQoKTtcbnJldHVybiBmcm9tRW50cmllcyhcbm5hbWVzLm1hcCgobmFtZSk9PltuYW1lLGVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlW25hbWVdKV0pKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuW1FDTEFTU106J3RhZ2dlZCcsXG50YWc6Z2V0VGFnKHBhc3NhYmxlKSxcbnBheWxvYWQ6ZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhKFxucGFzc2FibGUsXG5lbmNvZGVUb0NhcERhdGFSZWN1cik7XG5cbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MpXG4gfSAke3EoJ3Nsb3QnKX06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgZW5jb2RlZD1lbmNvZGVQcm9taXNlVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTLFxuJ3Nsb3QnKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlRXJyb3JUb0NhcERhdGEocGFzc2FibGUsZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuaWYocWNsYXNzTWF0Y2hlcyhlbmNvZGVkLCdlcnJvcicpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidlcnJvcicpXG4gfTogJHtlbmNvZGVkfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYGludGVybmFsOiBVbnJlY29nbml6ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5jb25zdCBlbmNvZGVUb0NhcERhdGE9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gaGFyZGVuKGVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKSk7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZSkpO1xuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvQ2FwRGF0YShtYWtlRW5jb2RlVG9DYXBEYXRhKTtcbmhhcmRlbihtYWtlRW5jb2RlVG9DYXBEYXRhKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IChQcm9taXNlfFJlbW90YWJsZU9iamVjdCl9IFtkZWNvZGVQcm9taXNlRnJvbUNhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gRXJyb3J9IFtkZWNvZGVFcnJvckZyb21DYXBEYXRhXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0oc2xvdEVuY29kaW5nKT0+XG5GYWlsIGByZW1vdGFibGUgb3IgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Nsb3RFbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbUNhcERhdGE9KGVycm9yRW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyb3JFbmNvZGluZ31gO1xuXG4vKipcbiAqIFRoZSBjdXJyZW50IGVuY29kaW5nIGRvZXMgbm90IGdpdmUgdGhlIGRlY29kZXIgZW5vdWdoIGludG8gdG8gZGlzdGluZ3Vpc2hcbiAqIHdoZXRoZXIgYSBzbG90IHJlcHJlc2VudHMgYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLiBBcyBhbiBpbXBsZW1lbnRhdGlvblxuICogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmVcbiAqIHByb3ZpZGVkIGFuZCB0aGV5IG11c3QgYmUgdGhlIHNhbWUuXG4gKlxuICogVGhpcyBzZWVtcyBsaWtlIHRoZSBiZXN0IHN0YXJ0aW5nIHBvaW50IHRvIGluY3JlbWVudGFsbHkgZXZvbHZlIHRvIGFuXG4gKiBBUEkgd2hlcmUgdGhlc2UgY2FuIHJlbGlhYmx5IGRpZmZlci5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzRcbiAqXG4gKiBAcGFyYW0ge0RlY29kZU9wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBFbmNvZGluZykgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlRnJvbUNhcERhdGE9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPWRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YSxcbmRlY29kZVByb21pc2VGcm9tQ2FwRGF0YT1kb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVFcnJvckZyb21DYXBEYXRhPWRvbnREZWNvZGVFcnJvckZyb21DYXBEYXRhfT1cbmRlY29kZU9wdGlvbnM7XG5cbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhPT09ZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhfHxcbkZhaWwgYEFuIGltcGxlbWVudGF0aW9uIHJlc3RyaWN0aW9uIGZvciBub3c6IElmIGVpdGhlciBkZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSBvciBkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZSBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lOiAke3EoXG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YSlcbiB9IHZzICR7cShkZWNvZGVQcm9taXNlRnJvbUNhcERhdGEpfWA7XG5cbi8qKlxuICogYGRlY29kZUZyb21DYXBEYXRhYCBtYXkgcmVseSBvbiBganNvbkVuY29kZWRgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBqc29uRW5jb2RlZGBcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvQ2FwRGF0YWBcbiAqIGFib3ZlLCBpLmUuLCBgZGVjb2RlRnJvbUNhcERhdGFgIGNhbm5vdCByZWx5IG9uIGBqc29uRW5jb2RlZGAgYmVpbmcgYVxuICogdmFsaWQgbWFyc2hhbGxlZCByZXByZXNlbnRhdGlvbi4gUmF0aGVyLCBgZGVjb2RlRnJvbUNhcERhdGFgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30ganNvbkVuY29kZWQgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tQ2FwRGF0YT0oanNvbkVuY29kZWQpPT57XG5pZighaXNPYmplY3QoanNvbkVuY29kZWQpKXtcbi8qIHByaW1pdGl2ZXMgcGFzcyB0aHJvdWdoKi9cbnJldHVybiBqc29uRW5jb2RlZDtcbiB9XG5pZihpc0FycmF5KGpzb25FbmNvZGVkKSl7XG5yZXR1cm4ganNvbkVuY29kZWQubWFwKChlbmNvZGVkVmFsKT0+ZGVjb2RlRnJvbUNhcERhdGEoZW5jb2RlZFZhbCkpO1xuIH1lbHNlIGlmKGhhc1FDbGFzcyhqc29uRW5jb2RlZCkpe1xuY29uc3QgcWNsYXNzPWpzb25FbmNvZGVkW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCAke3EoUUNMQVNTKX0gdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuc3dpdGNoKHFjbGFzcyl7XG4vKiBFbmNvZGluZyBvZiBwcmltaXRpdmVzIG5vdCBoYW5kbGVkIGJ5IEpTT04qL1xuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdOYU4nOntcbnJldHVybiBOYU47XG4gfVxuY2FzZSdJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnLUluZmluaXR5Jzp7XG5yZXR1cm4tSW5maW5pdHk7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309anNvbkVuY29kZWQ7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuIEJpZ0ludChkaWdpdHMpO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBEZXByZWNhdGVkIHFjbGFzcy4gVE9ETyBtYWtlIGNvbmRpdGlvbmFsKi9cbi8qIG9uIGVudmlyb25tZW50IHZhcmlhYmxlLiBFdmVudHVhbGx5IHJlbW92ZSwgYnV0IGFmdGVyIGNvbmZpZGVudCovXG4vKiB0aGF0IHRoZXJlIGFyZSBubyBtb3JlIHN1cHBvcnRlZCBzZW5kZXJzLiovXG4vKiovXG5yZXR1cm4gU3ltYm9sLmFzeW5jSXRlcmF0b3I7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PWpzb25FbmNvZGVkO1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PWpzb25FbmNvZGVkO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLGRlY29kZUZyb21DYXBEYXRhKHBheWxvYWQpKTtcbiB9XG5jYXNlJ3Nsb3QnOntcbi8qIFNlZSBub3RlIGFib3ZlIGFib3V0IGhvdyB0aGUgY3VycmVudCBlbmNvZGluZyBjYW5ub3QgcmVsaWFibHkqL1xuLyogZGlzdGluZ3Vpc2ggd2hpY2ggd2Ugc2hvdWxkIGNhbGwsIHNvIGluIHRoZSBub24tZGVmYXVsdCBjYXNlKi9cbi8qIGJvdGggbXVzdCBiZSB0aGUgc2FtZSBhbmQgaXQgZG9lc24ndCBtYXR0ZXIgd2hpY2ggd2UgY2FsbC4qL1xuY29uc3QgZGVjb2RlZD1kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YShcbmpzb25FbmNvZGVkLFxuZGVjb2RlRnJvbUNhcERhdGEpO1xuXG4vKiBCRVdBUkU6IGNhcGRhdGEgZG9lcyBub3QgY2hlY2sgdGhhdCBgZGVjb2RlZGAgaXMqL1xuLyogYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLCBzaW5jZSB0aGF0IHdvdWxkIGJyZWFrIHNvbWUqL1xuLyogY2FwZGF0YSBjbGllbnRzLiBXZSBhcmUgZGVwcmVjYXRpbmcgY2FwZGF0YSwgYW5kIHRoZXNlIGNsaWVudHMqL1xuLyogd2lsbCBuZWVkIHRvIHVwZGF0ZSBiZWZvcmUgc3dpdGNoaW5nIHRvIHNtYWxsY2Fwcy4qL1xucmV0dXJuIGRlY29kZWQ7XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZGVjb2RlZD1kZWNvZGVFcnJvckZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbmlmKHBhc3NTdHlsZU9mKGRlY29kZWQpPT09J2Vycm9yJyl7XG5yZXR1cm4gZGVjb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YSBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7ZGVjb2RlZH1gO1xuIH1cbmNhc2UnaGlsYmVydCc6e1xuY29uc3R7b3JpZ2luYWwscmVzdH09anNvbkVuY29kZWQ7XG5oYXNPd25Qcm9wZXJ0eU9mKGpzb25FbmNvZGVkLCdvcmlnaW5hbCcpfHxcbkZhaWwgYEludmFsaWQgSGlsYmVydCBIb3RlbCBlbmNvZGluZyAke2pzb25FbmNvZGVkfWA7XG4vKiBEb24ndCBoYXJkZW4gc2luY2Ugd2UncmUgbm90IGRvbmUgbXV0YXRpbmcgaXQqL1xuY29uc3QgcmVzdWx0PXtbUUNMQVNTXTpkZWNvZGVGcm9tQ2FwRGF0YShvcmlnaW5hbCl9O1xuaWYoaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwncmVzdCcpKXtcbmNvbnN0IGlzTm9uRW1wdHlPYmplY3Q9XG50eXBlb2YgcmVzdD09PSdvYmplY3QnJiZcbnJlc3QhPT1udWxsJiZcbm93bktleXMocmVzdCkubGVuZ3RoPj0xO1xuaWYoIWlzTm9uRW1wdHlPYmplY3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyBtdXN0IGJlIGEgbm9uLWVtcHR5IG9iamVjdDogJHtyZXN0fWA7XG4gfVxuY29uc3QgcmVzdE9iaj1kZWNvZGVGcm9tQ2FwRGF0YShyZXN0KTtcbi8qIFRPRE8gcmVhbGx5IHNob3VsZCBhc3NlcnQgdGhhdCBgcGFzc1N0eWxlT2YocmVzdClgIGlzKi9cbi8qIGAnY29weVJlY29yZCdgIGJ1dCB3ZSdkIGhhdmUgdG8gaGFyZGVuIGl0IGFuZCBpdCBpcyB0b28qL1xuLyogZWFybHkgdG8gZG8gdGhhdC4qL1xuIWhhc093blByb3BlcnR5T2YocmVzdE9iaixRQ0xBU1MpfHxcbkZhaWwgYFJlc3QgbXVzdCBub3QgY29udGFpbiBpdHMgb3duIGRlZmluaXRpb24gb2YgJHtxKFFDTEFTUyl9YDtcbmRlZmluZVByb3BlcnRpZXMocmVzdWx0LGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocmVzdE9iaikpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBUaGlzIGlzIHRoZSBlcnJvciBjYXNlIHdlJ3JlIHRlc3RpbmcgZm9yKi9cbmNhc2UnaWJpZCc6e1xudGhyb3cgRmFpbCBgVGhlIGNhcERhdGEgcHJvdG9jb2wgbm8gbG9uZ2VyIHN1cHBvcnRzICR7cShRQ0xBU1MpfSAke3EoXG5xY2xhc3MpXG4gfWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2V7XG5hc3NlcnQodHlwZW9mIGpzb25FbmNvZGVkPT09J29iamVjdCcmJmpzb25FbmNvZGVkIT09bnVsbCk7XG5jb25zdCBkZWNvZGVFbnRyeT0oW25hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5ICR7cShuYW1lKX0gb2YgJHtqc29uRW5jb2RlZH0gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoanNvbkVuY29kZWQpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVGcm9tQ2FwRGF0YSk7XG4gfTskaM2PX29uY2UubWFrZURlY29kZUZyb21DYXBEYXRhKG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJRQ0xBU1MiOlsiUUNMQVNTIl0sIm1ha2VFbmNvZGVUb0NhcERhdGEiOlsibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJtYWtlRGVjb2RlRnJvbUNhcERhdGEiOlsibWFrZURlY29kZUZyb21DYXBEYXRhIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABT14RCrOwAAqzsAAC0AAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIiwibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IHBhc3NTdHlsZU9mLGlzRXJyb3JMaWtlLG1ha2VUYWdnZWQsZ2V0VGFnLGhhc093blByb3BlcnR5T2YsYXNzZXJ0UGFzc2FibGVTeW1ib2wsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZSxYLEZhaWwscTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRozY9fYSA9PiAobWFrZVRhZ2dlZCA9ICRozY9fYSldXSxbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRozY9fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV0sW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc2FibGUsIFJlbW90YWJsZX0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZScgKi9cbi8qIEZJWE1FIGRlZmluZSBhY3R1YWwgdHlwZXMqL1xuLyoqIEB0eXBlZGVmIHthbnl9IFNtYWxsY2Fwc0VuY29kaW5nICovXG4vKiogQHR5cGVkZWYge2FueX0gU21hbGxjYXBzRW5jb2RpbmdVbmlvbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtpcyxlbnRyaWVzLGZyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0IEJBTkc9JyEnLmNoYXJDb2RlQXQoMCk7XG5jb25zdCBEQVNIPSctJy5jaGFyQ29kZUF0KDApO1xuXG4vKipcbiAqIEFuIGBlbmNvZGVUb1NtYWxsY2Fwc2AgZnVuY3Rpb24gdGFrZXMgYSBwYXNzYWJsZSBhbmQgcmV0dXJucyBhXG4gKiBKU09OLXJlcHJlc2VudGFibGUgb2JqZWN0IChpLmUuLCByb3VuZC10cmlwcGluZyBpdCB0aHJvdWdoXG4gKiBgSlNPTi5zdHJpbmdpZnlgIGFuZCBgSlNPTi5wYXJzZWAgd2l0aCBubyByZXBsYWNlcnMgb3IgcmV2aXZlcnNcbiAqIHJldHVybnMgYW4gZXF1aXZhbGVudCBzdHJ1Y3R1cmUgZXhjZXB0IGZvciBvYmplY3QgaWRlbnRpdHkpLlxuICogV2UgY2FsbCB0aGlzIHJlcHJlc2VudGF0aW9uIGEgU21hbGxjYXBzIEVuY29kaW5nLlxuICpcbiAqIEEgYGRlY29kZUZyb21TbWFsbGNhcHNgIGZ1bmN0aW9uIHRha2VzIGFzIGFyZ3VtZW50IHdoYXQgaXRcbiAqICphc3N1bWVzKiBpcyB0aGUgcmVzdWx0IG9mIGEgcGxhaW4gYEpTT04ucGFyc2VgIHdpdGggbm8gcmVzb2x2ZXIuIEl0IHRoZW5cbiAqIG11c3QgdmFsaWRhdGUgdGhhdCBpdCBpcyBhIHZhbGlkIFNtYWxsY2FwcyBFbmNvZGluZywgYW5kIGlmIGl0IGlzLFxuICogcmV0dXJuIGEgY29ycmVzcG9uZGluZyBwYXNzYWJsZS5cbiAqXG4gKiBTbWFsbGNhcHMgY29uc2lkZXJzIHRoZSBjaGFyYWN0ZXJzIGJldHdlZW4gYCFgIChhc2NpaSBjb2RlIDMzLCBCQU5HKVxuICogYW5kIGAtYCAoYXNjaWkgY29kZSA0NSwgREFTSCkgdG8gYmUgc3BlY2lhbCBwcmVmaXhlcyBhbGxvd2luZ1xuICogcmVwcmVzZW50YXRpb24gb2YgSlNPTi1pbmNvbXBhdGlibGUgZGF0YSB1c2luZyBzdHJpbmdzLlxuICogVGhlc2UgY2hhcmFjdGVycywgaW4gb3JkZXIsIGFyZSBgIVwiIyQlJicoKSorLC1gXG4gKiBPZiB0aGVzZSwgc21hbGxjYXBzIGN1cnJlbnRseSB1c2VzIHRoZSBmb2xsb3dpbmc6XG4gKlxuICogICogYCFgIC0gZXNjYXBlZCBzdHJpbmdcbiAqICAqIGArYCAtIG5vbi1uZWdhdGl2ZSBiaWdpbnRcbiAqICAqIGAtYCAtIG5lZ2F0aXZlIGJpZ2ludFxuICogICogYCNgIC0gbWFuaWZlc3QgY29uc3RhbnRcbiAqICAqIGAlYCAtIHN5bWJvbFxuICogICogYCRgIC0gcmVtb3RhYmxlXG4gKiAgKiBgJmAgLSBwcm9taXNlXG4gKlxuICogQWxsIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycyAoYFwiJygpKixgKSBhcmUgcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuXG4gKlxuICogVGhlIG1hbmlmZXN0IGNvbnN0YW50cyB0aGF0IHNtYWxsY2FwcyBjdXJyZW50bHkgdXNlcyBmb3IgdmFsdWVzOlxuICogICogYCN1bmRlZmluZWRgXG4gKiAgKiBgI05hTmBcbiAqICAqIGAjSW5maW5pdHlgXG4gKiAgKiBgIy1JbmZpbml0eWBcbiAqXG4gKiBhbmQgZm9yIHByb3BlcnR5IG5hbWVzIGFuYWxvZ291cyB0byBjYXBkYXRhIEBxY2xhc3M6XG4gKiAgKiBgI3RhZ2BcbiAqICAqIGAjZXJyb3JgXG4gKlxuICogQWxsIG90aGVyIGVuY29kZWQgc3RyaW5ncyBiZWdpbm5pbmcgd2l0aCBgI2AgYXJlIHJlc2VydmVkIGZvclxuICogZnV0dXJlIHVzZS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFN0clxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHN0YXJ0c1NwZWNpYWw9KGVuY29kZWRTdHIpPT57XG5pZihlbmNvZGVkU3RyPT09Jycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbi8qIGNoYXJDb2RlQXQoMCkgYW5kIG51bWJlciBjb21wYXJlIGlzIGEgYml0IGZhc3Rlci4qL1xuY29uc3QgY29kZT1lbmNvZGVkU3RyLmNoYXJDb2RlQXQoMCk7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgeW9kYSovXG5yZXR1cm4gQkFORzw9Y29kZSYmY29kZTw9REFTSDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZVRvU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIHJlbW90YWJsZTogUmVtb3RhYmxlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVFcnJvclRvU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz0ocmVtKT0+XG5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtyZW19YDtcblxuY29uc3QgZG9udEVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz0ocHJvbSk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwcm9tfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIpPT5cbkZhaWwgYGVycm9yIG9iamVjdCB1bmV4cGVjdGVkOiAke3EoZXJyKX1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlVG9TbWFsbGNhcHNPcHRpb25zfSBbZW5jb2RlT3B0aW9uc11cbiAqIGVuY29kZU9wdGlvbnMgaXMgYWN0dWFsbHkgb3B0aW9uYWwsIGJ1dCBub3QgbWFya2VkIGFzIHN1Y2ggdG8gd29yayBhcm91bmRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAyODZcbiAqXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW5jb2RlVG9TbWFsbGNhcHM9KGVuY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzPWRvbnRFbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyxcbmVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz1kb250RW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzLFxuZW5jb2RlRXJyb3JUb1NtYWxsY2Fwcz1kb250RW5jb2RlRXJyb3JUb1NtYWxsY2Fwc309XG5lbmNvZGVPcHRpb25zO1xuXG5jb25zdCBhc3NlcnRFbmNvZGVkRXJyb3I9KGVuY29kaW5nKT0+e1xudHlwZW9mIGVuY29kaW5nPT09J29iamVjdCcmJmhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyNlcnJvcicpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGhhdmUgXCIjZXJyb3JcIiBwcm9wZXJ0eTogJHtxKFxuZW5jb2RpbmcpXG4gfWA7XG4vKiBBc3NlcnQgdGhhdCB0aGUgI2Vycm9yIHByb3BlcnR5IGRlY29kZXMgdG8gYSBzdHJpbmcuKi9cbmNvbnN0IG1lc3NhZ2U9ZW5jb2RpbmdbJyNlcnJvciddO1xudHlwZW9mIG1lc3NhZ2U9PT0nc3RyaW5nJyYmKFxuIXN0YXJ0c1NwZWNpYWwobWVzc2FnZSl8fG1lc3NhZ2UuY2hhckF0KDApPT09JyEnKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBoYXZlIHN0cmluZyBtZXNzYWdlOiAke3EobWVzc2FnZSl9YDtcbiB9O1xuXG4vKipcbiAqIE11c3QgZW5jb2RlIGB2YWxgIGludG8gcGxhaW4gSlNPTiBkYXRhICpjYW5vbmljYWxseSosIHN1Y2ggdGhhdFxuICogYEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpID09PSBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKWAuIEZvciBtb3N0XG4gKiBlbmNvZGluZ3MsIHRoZSBvcmRlciBvZiBwcm9wZXJ0aWVzIG9mIGVhY2ggbm9kZSBvZiB0aGUgb3V0cHV0XG4gKiBzdHJ1Y3R1cmUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYWxnb3JpdGhtIGJlbG93IHdpdGhvdXQgc3BlY2lhbFxuICogYXJyYW5nZW1lbnQsIHVzdWFsbHkgYnkgYmVpbmcgZXhwcmVzc2VkIGRpcmVjdGx5IGFzIGFuIG9iamVjdCBsaXRlcmFsLlxuICogVGhlIGV4Y2VwdGlvbiBpcyBjb3B5UmVjb3Jkcywgd2hvc2UgbmF0dXJhbCBlbnVtZXJhdGlvbiBvcmRlclxuICogY2FuIGRpZmZlciBiZXR3ZWVuIGNvcHlSZWNvcmRzIHRoYXQgb3VyIGRpc3RyaWJ1dGVkIG9iamVjdCBzZW1hbnRpY3NcbiAqIGNvbnNpZGVycyB0byBiZSBlcXVpdmFsZW50LlxuICogU2luY2UsIGZvciBlYWNoIGNvcHlSZWNvcmQsIHdlIG9ubHkgYWNjZXB0IHN0cmluZyBwcm9wZXJ0eSBuYW1lcyxcbiAqIG5vdCBzeW1ib2xzLCB3ZSBjYW4gY2Fub25pY2FsbHkgc29ydCB0aGUgbmFtZXMgZmlyc3QuXG4gKiBKU09OLnN0cmluZ2lmeSB3aWxsIHRoZW4gdmlzaXQgdGhlc2UgaW4gdGhhdCBzb3J0ZWQgb3JkZXIuXG4gKlxuICogRW5jb2Rpbmcgd2l0aCBhIGNhbm9uaWNhbC1KU09OIGVuY29kZXIgd291bGQgYWxzbyBzb2x2ZSB0aGlzIGNhbm9uaWNhbG5lc3NcbiAqIHByb2JsZW0gaW4gYSBtb3JlIG1vZHVsYXIgYW5kIGVuY2Fwc3VsYXRlZCBtYW5uZXIuIE5vdGUgdGhhdCB0aGVcbiAqIGFjdHVhbCBvcmRlciBwcm9kdWNlZCBoZXJlLCB0aG91Z2ggaXQgYWdyZWVzIHdpdGggY2Fub25pY2FsLUpTT04gb25cbiAqIGNvcHlSZWNvcmQgcHJvcGVydHkgb3JkZXJpbmcsIGRpZmZlcnMgZnJvbSBjYW5vbmljYWwtSlNPTiBhcyBhIHdob2xlXG4gKiBpbiB0aGF0IHRoZSBvdGhlciByZWNvcmQgcHJvcGVydGllcyBhcmUgdmlzaXRlZCBpbiB0aGUgb3JkZXIgaW4gd2hpY2hcbiAqIHRoZXkgYXJlIGxpdGVyYWxseSB3cml0dGVuIGJlbG93LiBUT0RPIHBlcmhhcHMgd2Ugc2hvdWxkIGluZGVlZCBzd2l0Y2hcbiAqIHRvIGEgY2Fub25pY2FsIEpTT04gZW5jb2RlciwgYW5kIG5vdCBkZWxpY2F0ZWx5IGRlcGVuZCBvbiB0aGUgb3JkZXJcbiAqIGluIHdoaWNoIHRoZXNlIG9iamVjdCBsaXRlcmFscyBhcmUgd3JpdHRlbi5cbiAqXG4gKiBSZWFkZXJzIG11c3Qgbm90IGNhcmUgYWJvdXQgdGhpcyBvcmRlciBhbnl3YXkuIFdlIGltcG9zZSB0aGlzIHJlcXVpcmVtZW50XG4gKiBtYWlubHkgdG8gcmVkdWNlIG5vbi1kZXRlcm1pbmlzbSBleHBvc2VkIG91dHNpZGUgYSB2YXQuXG4gKlxuICogQHBhcmFtIHthbnl9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7U21hbGxjYXBzRW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb1NtYWxsY2Fwc2AgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb1NtYWxsY2Fwc2AgaXMgbm90XG4gKiBkaXJlY3RseSBleHBvc2VkLlxuICogV2hhdCdzIGV4cG9zZWQgaW5zdGVhZCBpcyBhIHdyYXBwZXIgdGhhdCBmcmVlemVzIHRoZSBvdXRwdXQgYmVmb3JlXG4gKiByZXR1cm5pbmcuIElmIHRoaXMgdHVybnMgb3V0IHRvIGltcGVkZSBzdGF0aWMgYW5hbHlzaXMgZm9yIGBoYXJkZW5gIHNhZmV0eSxcbiAqIHdlIGNhbiBhbHdheXMgcHV0IHRoZSAobm93IHJlZHVuZGFudCkgaGFyZGVucyBiYWNrIGluLiBUaGV5IGRvbid0IGh1cnQuXG4gKi9cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgaW50byBzbWFsbGNhcHMgc3RyaW5ncy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZihzdGFydHNTcGVjaWFsKHBhc3NhYmxlKSl7XG4vKiBTdHJpbmdzIHRoYXQgc3RhcnQgd2l0aCBhIHNwZWNpYWwgY2hhciBhcmUgcXVvdGVkIHdpdGggYCFgLiovXG4vKiBTaW5jZSBgIWAgaXMgaXRzZWxmIGEgc3BlY2lhbCBjaGFyYWN0ZXIsIHRoaXMgdHJpdmlhbGx5IGRvZXMqL1xuLyogdGhlIEhpbGJlcnQgaG90ZWwuIEFsc28sIHNpbmNlIHRoZSBzcGVjaWFsIGNoYXJhY3RlcnMgYXJlKi9cbi8qIGEgY29udGludW91cyBzdWJyYW5nZSBvZiBhc2NpaSwgdGhpcyBxdW90aW5nIGlzIHNvcnQtb3JkZXIqL1xuLyogcHJlc2VydmluZy4qL1xucmV0dXJuIGAhJHtwYXNzYWJsZX1gO1xuIH1cbi8qIEFsbCBvdGhlciBzdHJpbmdzIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJyN1bmRlZmluZWQnO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybicjTmFOJztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybicjSW5maW5pdHknO1xuIH1lbHNlIGlmKHBhc3NhYmxlPT09LUluZmluaXR5KXtcbnJldHVybicjLUluZmluaXR5JztcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0IHN0cj1TdHJpbmcocGFzc2FibGUpO1xucmV0dXJuICgvKiogQHR5cGUge2JpZ2ludH0gKi9wYXNzYWJsZTwwbj9zdHI6YCske3N0cn1gKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJuIGAlJHtuYW1lfWA7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKG5hbWUpLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm57XG4nI3RhZyc6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihnZXRUYWcocGFzc2FibGUpKSxcbnBheWxvYWQ6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZS5wYXlsb2FkKX07XG5cbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyQnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuLyogYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEJ1dCBsaW50ZXIgY29uZnVzZWQqL1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIkXCI6ICR7cmVzdWx0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuY2hhckF0KDApPT09JyYnKXtcbnJldHVybiByZXN1bHQ7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJlwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvclRvU21hbGxjYXBzKHBhc3NhYmxlLGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuYXNzZXJ0RW5jb2RlZEVycm9yKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9TbWFsbGNhcHM9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5jb25zdCByZXN1bHQ9aGFyZGVuKFxuZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKSk7XG5cbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwcyk7XG4gfTskaM2PX29uY2UubWFrZUVuY29kZVRvU21hbGxjYXBzKG1ha2VFbmNvZGVUb1NtYWxsY2Fwcyk7XG5oYXJkZW4obWFrZUVuY29kZVRvU21hbGxjYXBzKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVGcm9tU21hbGxjYXBzT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBSZW1vdGFibGV9IFtkZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VGcm9tU21hbGxjYXBzXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRFcnJvcjogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzXVxuICovXG5cbmNvbnN0IGRvbnREZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7cShlbmNvZGluZyl9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0RlY29kZUZyb21TbWFsbGNhcHNPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogU21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZUZyb21TbWFsbGNhcHM9KGRlY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9ZG9udERlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9ZG9udERlY29kZUVycm9yRnJvbVNtYWxsY2Fwc309XG5kZWNvZGVPcHRpb25zO1xuXG4vKipcbiAqIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBtYXkgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIHRoZSByZXN1bHQgb2YgYVxuICogcGxhaW4gY2FsbCB0byBKU09OLnBhcnNlLiBIb3dldmVyLCBpdCAqY2Fubm90KiByZWx5IG9uIGBlbmNvZGluZ2BcbiAqIGhhdmluZyBiZWVuIHByb2R1Y2VkIGJ5IEpTT04uc3RyaW5naWZ5IG9uIHRoZSBvdXRwdXQgb2YgYGVuY29kZVRvU21hbGxjYXBzYFxuICogYWJvdmUsIGkuZS4sIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBjYW5ub3QgcmVseSBvbiBgZW5jb2RpbmdgIGJlaW5nIGFcbiAqIHZhbGlkIG1hcnNoYWxsZWQgcmVwcmVzZW50YXRpb24uIFJhdGhlciwgYGRlY29kZUZyb21TbWFsbGNhcHNgIG11c3RcbiAqIHZhbGlkYXRlIHRoYXQuXG4gKlxuICogQHBhcmFtIHtTbWFsbGNhcHNFbmNvZGluZ30gZW5jb2RpbmcgbXVzdCBiZSBoYXJkZW5lZFxuICovXG5jb25zdCBkZWNvZGVGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PntcbnN3aXRjaCh0eXBlb2YgZW5jb2Rpbmcpe1xuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzp7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY2FzZSdzdHJpbmcnOntcbmlmKCFzdGFydHNTcGVjaWFsKGVuY29kaW5nKSl7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuY29uc3QgYz1lbmNvZGluZy5jaGFyQXQoMCk7XG5zd2l0Y2goYyl7XG5jYXNlJyEnOntcbi8qIHVuLWhpbGJlcnQtaWZ5IHRoZSBzdHJpbmcqL1xucmV0dXJuIGVuY29kaW5nLnNsaWNlKDEpO1xuIH1cbmNhc2UnJSc6e1xucmV0dXJuIHBhc3NhYmxlU3ltYm9sRm9yTmFtZShlbmNvZGluZy5zbGljZSgxKSk7XG4gfVxuY2FzZScjJzp7XG5zd2l0Y2goZW5jb2Rpbmcpe1xuY2FzZScjdW5kZWZpbmVkJzp7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNhc2UnI05hTic6e1xucmV0dXJuIE5hTjtcbiB9XG5jYXNlJyNJbmZpbml0eSc6e1xucmV0dXJuIEluZmluaXR5O1xuIH1cbmNhc2UnIy1JbmZpbml0eSc6e1xucmV0dXJuLUluZmluaXR5O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGB1bmtub3duIGNvbnN0YW50IFwiJHtxKGVuY29kaW5nKX1cImAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH1cbmNhc2UnKyc6XG5jYXNlJy0nOntcbnJldHVybiBCaWdJbnQoZW5jb2RpbmcpO1xuIH1cbmNhc2UnJCc6e1xuY29uc3QgcmVzdWx0PWRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG4vKiBAdHMtaWdub3JlIFhYWCBTbWFsbENhcHNFbmNvZGluZyovXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3JlbW90YWJsZScpe1xuRmFpbCBgaW50ZXJuYWw6IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGEgcmVtb3RhYmxlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuY2FzZScmJzp7XG5jb25zdCByZXN1bHQ9ZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG5pZihwYXNzU3R5bGVPZihyZXN1bHQpIT09J3Byb21pc2UnKXtcbkZhaWwgYGludGVybmFsOiBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYSBwcm9taXNlOiAke3Jlc3VsdH1gO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBTcGVjaWFsIGNoYXIgJHtxKFxuYylcbiB9IHJlc2VydmVkIGZvciBmdXR1cmUgdXNlOiAke2VuY29kaW5nfWA7XG4gfX1cblxuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihlbmNvZGluZz09PW51bGwpe1xucmV0dXJuIGVuY29kaW5nO1xuIH1cblxuaWYoaXNBcnJheShlbmNvZGluZykpe1xucmV0dXJuIGVuY29kaW5nLm1hcCgodmFsKT0+ZGVjb2RlRnJvbVNtYWxsY2Fwcyh2YWwpKTtcbiB9XG5cbmlmKGhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyN0YWcnKSl7XG5jb25zdHsnI3RhZyc6dGFnLHBheWxvYWQsLi4ucmVzdH09ZW5jb2Rpbmc7XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVmFsdWUgb2YgXCIjdGFnXCIsIHRoZSB0YWcsIG11c3QgYmUgYSBzdHJpbmc6ICR7ZW5jb2Rpbmd9YDtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGAjdGFnIHJlY29yZCB1bmV4cGVjdGVkIHByb3BlcnRpZXM6ICR7cShvd25LZXlzKHJlc3QpKX1gO1xucmV0dXJuIG1ha2VUYWdnZWQoXG5kZWNvZGVGcm9tU21hbGxjYXBzKHRhZyksXG5kZWNvZGVGcm9tU21hbGxjYXBzKHBheWxvYWQpKTtcblxuIH1cblxuaWYoaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI2Vycm9yJykpe1xuY29uc3QgcmVzdWx0PWRlY29kZUVycm9yRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbnBhc3NTdHlsZU9mKHJlc3VsdCk9PT0nZXJyb3InfHxcbkZhaWwgYGludGVybmFsOiBkZWNvZGVFcnJvckZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGFuIGVycm9yOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5cbmNvbnN0IGRlY29kZUVudHJ5PShbZW5jb2RlZE5hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgZW5jb2RlZE5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbmVuY29kZWROYW1lKVxuIH0gb2YgJHtlbmNvZGluZ30gbXVzdCBiZSBhIHN0cmluZ2A7XG5lbmNvZGVkTmFtZS5jaGFyQXQoMCkhPT0nIyd8fFxuRmFpbCBgVW5yZWNvZ25pemVkIHJlY29yZCB0eXBlICR7cShlbmNvZGVkTmFtZSl9OiAke2VuY29kaW5nfWA7XG5jb25zdCBuYW1lPWRlY29kZUZyb21TbWFsbGNhcHMoZW5jb2RlZE5hbWUpO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBEZWNvZGVkIHByb3BlcnR5IG5hbWUgJHtuYW1lfSBmcm9tICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoZW5jb2RpbmcpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogdW5yZWNvZ25pemVkIEpTT04gdHlwZW9mICR7cShcbnR5cGVvZiBlbmNvZGluZylcbiB9OiAke2VuY29kaW5nfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZUZyb21TbWFsbGNhcHMpO1xuIH07JGjNj19vbmNlLm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFbmNvZGVUb1NtYWxsY2FwcyI6WyJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiXSwibWFrZURlY29kZUZyb21TbWFsbGNhcHMiOlsibWFrZURlY29kZUZyb21TbWFsbGNhcHMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAcE6fMmEsAABhLAAAKgAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc3siaW1wb3J0cyI6WyJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vZXJyb3JzIiwiLi9lbmNvZGVUb0NhcERhdGEuanMiXSwiZXhwb3J0cyI6WyJkZWNvZGVUb0p1c3RpbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBOYXQsZ2V0RXJyb3JDb25zdHJ1Y3Rvcixpc09iamVjdCxwYXNzYWJsZVN5bWJvbEZvck5hbWUscSxYLEZhaWwsUUNMQVNTOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjNj19hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQGltcG9ydCB7RW5jb2Rpbmd9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3N0cmluZ2lmeTpxdW90ZX09SlNPTjtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbmRlbnRlclxuICogQHByb3BlcnR5IHsob3BlbkJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBvcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gbGluZVxuICogQHByb3BlcnR5IHsodG9rZW46IHN0cmluZykgPT4gbnVtYmVyfSBuZXh0XG4gKiBAcHJvcGVydHkgeyhjbG9zZUJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBjbG9zZVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGRvbmVcbiAqL1xuXG4vKipcbiAqIEdlbmVyb3VzIHdoaXRlc3BhY2UgZm9yIHJlYWRhYmlsaXR5XG4gKlxuICogQHJldHVybnMge0luZGVudGVyfVxuICovXG5jb25zdCBtYWtlWWVzSW5kZW50ZXI9KCk9PntcbmNvbnN0IHN0cmluZ3M9W107XG5sZXQgbGV2ZWw9MDtcbmxldCBuZWVkU3BhY2U9ZmFsc2U7XG5jb25zdCBsaW5lPSgpPT57XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKCdcXG4nLCcgICcucmVwZWF0KGxldmVsKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT57XG5sZXZlbCs9MTtcbmlmKG5lZWRTcGFjZSl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKG9wZW5CcmFja2V0KTtcbiB9LFxubGluZSxcbm5leHQ6KHRva2VuKT0+e1xuaWYobmVlZFNwYWNlJiZ0b2tlbiE9PScsJyl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9dHJ1ZTtcbnJldHVybiBzdHJpbmdzLnB1c2godG9rZW4pO1xuIH0sXG5jbG9zZTooY2xvc2VCcmFja2V0KT0+e1xuYXNzZXJ0KGxldmVsPj0xKTtcbmxldmVsLT0xO1xubGluZSgpO1xucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT57XG5hc3NlcnQuZXF1YWwobGV2ZWwsMCk7XG5yZXR1cm4gc3RyaW5ncy5qb2luKCcnKTtcbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIElmIHRoZSBsYXN0IGNoYXJhY3RlciBvZiBvbmUgdG9rZW4gdG9nZXRoZXIgd2l0aCB0aGUgZmlyc3QgY2hhcmFjdGVyXG4gKiBvZiB0aGUgbmV4dCB0b2tlbiBtYXRjaGVzIHRoaXMgcGF0dGVybiwgdGhlbiB0aGUgdHdvIHRva2VucyBtdXN0IGJlXG4gKiBzZXBhcmF0ZWQgYnkgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZSB0aGVpciBtZWFuaW5nLiBPdGhlcndpc2UgdGhlXG4gKiB3aGl0ZXNwYWNlIGluIHVubmVjZXNzYXJ5LlxuICpcbiAqIFRoZSBgPCFgIGFuZCBgLT5gIGNhc2VzIHByZXZlbnQgdGhlIGFjY2lkZW50YWwgZm9ybWF0aW9uIG9mIGFuXG4gKiBodG1sLWxpa2UgY29tbWVudC4gSSBkb24ndCB0aGluayB0aGUgZG91YmxlIGFuZ2xlIGJyYWNrZXRzIGFyZSBhY3R1YWxseVxuICogbmVlZGVkIGJ1dCBJIGhhdmVuJ3QgdGhvdWdodCBhYm91dCBpdCBlbm91Z2ggdG8gcmVtb3ZlIHRoZW0uXG4gKi9cbmNvbnN0IGJhZFBhaXJQYXR0ZXJuPS9eKD86XFx3XFx3fDw8fD4+fFxcK1xcK3wtLXw8IXwtPikkLztcblxuLyoqXG4gKiBNaW5pbXVtIHdoaXRlc3BhY2UgbmVlZGVkIHRvIHByZXNldmUgbWVhbmluZy5cbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VOb0luZGVudGVyPSgpPT57XG4vKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuY29uc3Qgc3RyaW5ncz1bXTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT5zdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpLFxubGluZTooKT0+c3RyaW5ncy5sZW5ndGgsXG5uZXh0Oih0b2tlbik9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xKXtcbmNvbnN0IGxhc3Q9c3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzIC0tIGVycm9yKi9cbmlmKGxhc3QubGVuZ3RoPj0xJiZ0b2tlbi5sZW5ndGg+PTEpe1xuY29uc3QgcGFpcj0gYCR7bGFzdFtsYXN0Lmxlbmd0aC0xXX0ke3Rva2VuWzBdfWA7XG5pZihiYWRQYWlyUGF0dGVybi50ZXN0KHBhaXIpKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbiB9XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5pZihzdHJpbmdzLmxlbmd0aD49MSYmc3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXT09PScsJyl7XG5zdHJpbmdzLnBvcCgpO1xuIH1cbnJldHVybiBzdHJpbmdzLnB1c2goY2xvc2VCcmFja2V0KTtcbiB9LFxuZG9uZTooKT0+c3RyaW5ncy5qb2luKCcnKX0pO1xuXG4gfTtcblxuY29uc3QgaWRlbnRQYXR0ZXJuPS9eW2EtekEtWl1cXHcqJC87XG5oYXJkZW4oaWRlbnRQYXR0ZXJuKTtcbmNvbnN0IEF0QXRQcmVmaXhQYXR0ZXJuPS9eQEAoLiopJC87XG5oYXJkZW4oQXRBdFByZWZpeFBhdHRlcm4pO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kaW5nXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBzaG91bGRJbmRlbnRcbiAqIEBwYXJhbSB7YW55W119IFtzbG90c11cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGRlY29kZVRvSnVzdGluPShlbmNvZGluZyxzaG91bGRJbmRlbnQ9ZmFsc2Usc2xvdHM9W10pPT57XG4vKipcbiAqIFRoZSBmaXJzdCBwYXNzIGRvZXMgc29tZSBpbnB1dCB2YWxpZGF0aW9uLlxuICogSXRzIGNvbnRyb2wgZmxvdyBzaG91bGQgbWlycm9yIGByZWN1cmAgYXMgY2xvc2VseSBhcyBwb3NzaWJsZVxuICogYW5kIHRoZSB0d28gc2hvdWxkIGJlIG1haW50YWluZWQgdG9nZXRoZXIuIFRoZXkgbXVzdCB2aXNpdCBldmVyeXRoaW5nXG4gKiBpbiB0aGUgc2FtZSBvcmRlci5cbiAqXG4gKiBUT0RPIG5vdyB0aGF0IGliaWRzIGFyZSBnb25lLCB3ZSBzaG91bGQgZm9sZCB0aGlzIGJhY2sgdG9nZXRoZXIgaW50b1xuICogb25lIHZhbGlkYXRpbmcgcGFzcy5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgcHJlcGFyZT0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG5yZXR1cm47XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBxY2xhc3MgdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG5yZXR1cm47XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbnJldHVybjtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKHRhZywnc3RyaW5nJyk7XG5wcmVwYXJlKHBheWxvYWQpO1xucmV0dXJuO1xuIH1cbmNhc2Unc2xvdCc6e1xuY29uc3R7aW5kZXgsaWZhY2V9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbk5hdChpbmRleCk7XG5pZihpZmFjZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKGlmYWNlLCdzdHJpbmcnKTtcbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xuJ29yaWdpbmFsJ2luIHJhd1RyZWV8fFxuRmFpbCBgSW52YWxpZCBIaWxiZXJ0IEhvdGVsIGVuY29kaW5nICR7cmF3VHJlZX1gO1xucHJlcGFyZShvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmlmKHR5cGVvZiByZXN0IT09J29iamVjdCcpe1xudGhyb3cgRmFpbCBgUmVzdCAke3Jlc3R9IGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0YDtcbiB9XG5pZihyZXN0PT09bnVsbCl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgbnVsbGA7XG4gfVxuaWYoaXNBcnJheShyZXN0KSl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgYW4gYXJyYXlgO1xuIH1cbmlmKFFDTEFTUyBpbiByZXN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgJHtyZXN0fSBtdXN0IG5vdCBjb250YWluICR7cShRQ0xBU1MpfWA7XG4gfVxuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbnR5cGVvZiBuYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG5wcmVwYXJlKHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgbmFtZSl9YDtcbiB9XG5nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpIT09dW5kZWZpbmVkfHxcbkZhaWwgYE11c3QgYmUgdGhlIG5hbWUgb2YgYW4gRXJyb3IgY29uc3RydWN0b3IgJHtuYW1lfWA7XG50eXBlb2YgbWVzc2FnZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbWVzc2FnZSB0eXBlb2YgJHtxKHR5cGVvZiBtZXNzYWdlKX1gO1xucmV0dXJuO1xuIH1cblxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbnByZXBhcmUocmF3VHJlZVtpXSk7XG4gfVxuIH1lbHNle1xuY29uc3QgbmFtZXM9b3duS2V5cyhyYXdUcmVlKTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbmlmKHR5cGVvZiBuYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG4gfVxucHJlcGFyZShyYXdUcmVlW25hbWVdKTtcbiB9XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VJbmRlbnRlcj1zaG91bGRJbmRlbnQ/bWFrZVllc0luZGVudGVyOm1ha2VOb0luZGVudGVyO1xubGV0IG91dD1tYWtlSW5kZW50ZXIoKTtcblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBzZWNvbmQgcGFzcyByZWN1cnNpb24gYWZ0ZXIgdGhlIGZpcnN0IHBhc3MgYHByZXBhcmVgLlxuICogVGhlIGZpcnN0IHBhc3MgZGlkIHNvbWUgaW5wdXQgdmFsaWRhdGlvbiBzb1xuICogaGVyZSB3ZSBjYW4gc2FmZWx5IGFzc3VtZSBldmVyeXRoaW5nIHRob3NlIHRoaW5ncyBhcmUgdmFsaWRhdGVkLlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHtudW1iZXJ9XG4gKi9cbmNvbnN0IGRlY29kZT0ocmF3VHJlZSk9Pntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gcmVjdXIocmF3VHJlZSk7XG4gfTtcblxuY29uc3QgZGVjb2RlUHJvcGVydHk9KG5hbWUsdmFsdWUpPT57XG5vdXQubGluZSgpO1xuaWYobmFtZT09PSdfX3Byb3RvX18nKXtcbi8qIEphdmFTY3JpcHQgaW50ZXJwcmV0cyBge19fcHJvdG9fXzogeCwgLi4ufWAqL1xuLyogYXMgbWFraW5nIGFuIG9iamVjdCBpbmhlcml0aW5nIGZyb20gYHhgLCB3aGVyZWFzKi9cbi8qIGluIEpTT04gaXQgaXMgc2ltcGx5IGEgcHJvcGVydHkgbmFtZS4gUHJlc2VydmUgdGhlKi9cbi8qIEpTT04gbWVhbmluZy4qL1xub3V0Lm5leHQoIGBbXCJfX3Byb3RvX19cIl06YCk7XG4gfWVsc2UgaWYoaWRlbnRQYXR0ZXJuLnRlc3QobmFtZSkpe1xub3V0Lm5leHQoIGAke25hbWV9OmApO1xuIH1lbHNle1xub3V0Lm5leHQoIGAke3F1b3RlKG5hbWUpfTpgKTtcbiB9XG5kZWNvZGUodmFsdWUpO1xub3V0Lm5leHQoJywnKTtcbiB9O1xuXG4vKipcbiAqIE1vZGVsZWQgYWZ0ZXIgYGZ1bGxSZXZpdmVgIGluIG1hcnNoYWwuanNcbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCByZWN1cj0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG4vKiBwcmltaXRpdmVzIGdldCBxdW90ZWQqL1xucmV0dXJuIG91dC5uZXh0KHF1b3RlKHJhd1RyZWUpKTtcbiB9XG4vKiBBc3NlcnRpb25zIG9mIHRoZSBhYm92ZSB0byBuYXJyb3cgdGhlIHR5cGUuKi9cbmFzc2VydC50eXBlb2YocmF3VHJlZSwnb2JqZWN0Jyk7XG5hc3NlcnQocmF3VHJlZSE9PW51bGwpO1xuaWYoUUNMQVNTIGluIHJhd1RyZWUpe1xuY29uc3QgcWNsYXNzPXJhd1RyZWVbUUNMQVNTXTtcbmFzc2VydC50eXBlb2YocWNsYXNzLCdzdHJpbmcnKTtcbmFzc2VydCghaXNBcnJheShyYXdUcmVlKSk7XG4vKiBTd2l0Y2hpbmcgb24gYGVuY29kZWRbUUNMQVNTXWAgKG9yIGFueXRoaW5nIGxlc3MgZGlyZWN0LCBsaWtlKi9cbi8qIGBxY2xhc3NgKSBkb2VzIG5vdCBkaXNjcmltaW5hdGUgcmF3VHJlZSBpbiB0eXBlc2NyaXB0QDQuMi4zIGFuZCovXG4vKiBlYXJsaWVyLiovXG5zd2l0Y2gocmF3VHJlZVsnQHFjbGFzcyddKXtcbi8qIEVuY29kaW5nIG9mIHByaW1pdGl2ZXMgbm90IGhhbmRsZWQgYnkgSlNPTiovXG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ05hTic6XG5jYXNlJ0luZmluaXR5JzpcbmNhc2UnLUluZmluaXR5Jzp7XG4vKiBUaGVpciBxY2xhc3MgaXMgdGhlaXIgZXhwcmVzc2lvbiBzb3VyY2UuKi9cbnJldHVybiBvdXQubmV4dChxY2xhc3MpO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGRpZ2l0cywnc3RyaW5nJyk7XG5yZXR1cm4gb3V0Lm5leHQoIGAke0JpZ0ludChkaWdpdHMpfW5gKTtcbiB9XG5jYXNlJ0BAYXN5bmNJdGVyYXRvcic6e1xuLyogVE9ETyBkZXByZWNhdGVkLiBFdmVudHVhbGx5IHJlbW92ZS4qL1xucmV0dXJuIG91dC5uZXh0KCdTeW1ib2wuYXN5bmNJdGVyYXRvcicpO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5jb25zdHtuYW1lfT1yYXdUcmVlO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbmNvbnN0IHN5bT1wYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG5hc3NlcnQudHlwZW9mKHN5bSwnc3ltYm9sJyk7XG5jb25zdCByZWdpc3RlcmVkTmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihyZWdpc3RlcmVkTmFtZT09PXVuZGVmaW5lZCl7XG5jb25zdCBtYXRjaD1BdEF0UHJlZml4UGF0dGVybi5leGVjKG5hbWUpO1xuYXNzZXJ0KG1hdGNoIT09bnVsbCk7XG5jb25zdCBzdWZmaXg9bWF0Y2hbMV07XG5hc3NlcnQoU3ltYm9sW3N1ZmZpeF09PT1zeW0pO1xuYXNzZXJ0KGlkZW50UGF0dGVybi50ZXN0KHN1ZmZpeCkpO1xucmV0dXJuIG91dC5uZXh0KCBgU3ltYm9sLiR7c3VmZml4fWApO1xuIH1cbnJldHVybiBvdXQubmV4dCggYFN5bWJvbC5mb3IoJHtxdW90ZShyZWdpc3RlcmVkTmFtZSl9KWApO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdHt0YWcscGF5bG9hZH09cmF3VHJlZTtcbm91dC5uZXh0KCBgbWFrZVRhZ2dlZCgke3F1b3RlKHRhZyl9LGApO1xuZGVjb2RlKHBheWxvYWQpO1xucmV0dXJuIG91dC5uZXh0KCcpJyk7XG4gfVxuXG5jYXNlJ3Nsb3QnOntcbmxldHtpZmFjZX09cmF3VHJlZTtcbmNvbnN0IGluZGV4PU51bWJlcihOYXQocmF3VHJlZS5pbmRleCkpO1xuY29uc3QgbmVzdGVkUmVuZGVyPShhcmcpPT57XG5jb25zdCBvbGRPdXQ9b3V0O1xudHJ5e1xub3V0PW1ha2VOb0luZGVudGVyKCk7XG5kZWNvZGUoYXJnKTtcbnJldHVybiBvdXQuZG9uZSgpO1xuIH1maW5hbGx5e1xub3V0PW9sZE91dDtcbiB9XG4gfTtcbmlmKGluZGV4PHNsb3RzLmxlbmd0aCl7XG5jb25zdCBzbG90PW5lc3RlZFJlbmRlcihzbG90c1tpbmRleF0pO1xuaWYoaWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdFRvVmFsKCR7c2xvdH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3RUb1ZhbCgke3Nsb3R9LCR7aWZhY2V9KWApO1xuIH1lbHNlIGlmKGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0pYCk7XG4gfVxuaWZhY2U9bmVzdGVkUmVuZGVyKGlmYWNlKTtcbnJldHVybiBvdXQubmV4dCggYHNsb3QoJHtpbmRleH0sJHtpZmFjZX0pYCk7XG4gfVxuXG5jYXNlJ2hpbGJlcnQnOntcbmNvbnN0e29yaWdpbmFsLHJlc3R9PXJhd1RyZWU7XG5vdXQub3BlbigneycpO1xuZGVjb2RlUHJvcGVydHkoUUNMQVNTLG9yaWdpbmFsKTtcbmlmKCdyZXN0J2luIHJhd1RyZWUpe1xuYXNzZXJ0LnR5cGVvZihyZXN0LCdvYmplY3QnKTtcbmFzc2VydChyZXN0IT09bnVsbCk7XG5jb25zdCBuYW1lcz1vd25LZXlzKHJlc3QpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBQcm9wZXJ0eSBuYW1lICR7cShcbm5hbWUpXG4gfSBvZiAke3Jlc3R9IG11c3QgYmUgYSBzdHJpbmdgO1xuIH1cbmRlY29kZVByb3BlcnR5KG5hbWUscmVzdFtuYW1lXSk7XG4gfVxuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG5cbmNhc2UnZXJyb3InOntcbmNvbnN0e1xubmFtZSxcbm1lc3NhZ2UsXG5jYXVzZT11bmRlZmluZWQsXG5lcnJvcnM9dW5kZWZpbmVkfT1cbnJhd1RyZWU7XG5jYXVzZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBjYXVzZSBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbm5hbWUhPT0gYEFnZ3JlZ2F0ZUVycm9yYHx8XG5GYWlsIGBBZ2dyZWdhdGVFcnJvciBub3QgeWV0IGltcGxlbWVudGVkIGluIG1hcnNoYWwtanVzdGluYDtcbmVycm9ycz09PXVuZGVmaW5lZHx8XG5GYWlsIGBlcnJvciBlcnJvcnMgbm90IHlldCBpbXBsZW1lbnRlZCBpbiBtYXJzaGFsLWp1c3RpbmA7XG5yZXR1cm4gb3V0Lm5leHQoIGAke25hbWV9KCR7cXVvdGUobWVzc2FnZSl9KWApO1xuIH1cblxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChcblggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgnW10nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCdbJyk7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbm91dC5saW5lKCk7XG5kZWNvZGUocmF3VHJlZVtpXSk7XG5vdXQubmV4dCgnLCcpO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ10nKTtcbiB9XG4gfWVsc2V7XG4vKiByYXdUcmVlIGlzIGFuIGBFbmNvZGluZ1JlY29yZGAgd2hpY2ggb25seSBoYXMgc3RyaW5nIGtleXMsKi9cbi8qIGJ1dCBzaW5jZSBvd25LZXlzIGlzIG5vdCBnZW5lcmljLCBpdCBjYW4ndCBwcm9wYWdhdGUgdGhhdCovXG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmF3VHJlZSk7XG5pZihuYW1lcy5sZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgne30nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCd7Jyk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJhd1RyZWVbbmFtZV0pO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG4gfVxuIH07XG5wcmVwYXJlKGVuY29kaW5nKTtcbmRlY29kZShlbmNvZGluZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9OyRozY9fb25jZS5kZWNvZGVUb0p1c3RpbihkZWNvZGVUb0p1c3Rpbik7XG5oYXJkZW4oZGVjb2RlVG9KdXN0aW4pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVjb2RlVG9KdXN0aW4iOlsiZGVjb2RlVG9KdXN0aW4iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsQR5yBoHAAAaBwAALQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL21hcnNoYWwuanMiXSwiZXhwb3J0cyI6WyJwYXJzZSIsInN0cmluZ2lmeSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLG1ha2VNYXJzaGFsOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL21hcnNoYWwuanNcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaM2PX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEBpbXBvcnQge1Bhc3NhYmxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJyAqL1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFZhbFRvU2xvdD0odmFsKT0+XG5GYWlsIGBNYXJzaGFsJ3Mgc3RyaW5naWZ5IHJlamVjdHMgcHJlc2VuY2VzIGFuZCBwcm9taXNlcyAke3ZhbH1gO1xuXG4vKiogQHR5cGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFNsb3RUb1ZhbD0oc2xvdCxfaWZhY2UpPT5cbkZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3RzICR7c2xvdH1gO1xuXG5jb25zdCBiYWRBcnJheUhhbmRsZXI9aGFyZGVuKHtcbmdldDooX3RhcmdldCxuYW1lLF9yZWNlaXZlcik9PntcbmlmKG5hbWU9PT0nbGVuZ3RoJyl7XG5yZXR1cm4gMDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBNYXJzaGFsJ3MgcGFyc2UgbXVzdCBub3QgZW5jb2RlIGFueSBzbG90IHBvc2l0aW9ucyAke25hbWV9YDtcbiB9fSk7XG5cblxuY29uc3QgYmFkQXJyYXk9aGFyZGVuKG5ldyBQcm94eShoYXJkZW4oW10pLGJhZEFycmF5SGFuZGxlcikpO1xuXG5jb25zdHtzZXJpYWxpemUsdW5zZXJpYWxpemV9PW1ha2VNYXJzaGFsKFxuZG9Ob3RDb252ZXJ0VmFsVG9TbG90LFxuZG9Ob3RDb252ZXJ0U2xvdFRvVmFsLFxue1xuZXJyb3JUYWdnaW5nOidvZmYnLFxuLyogVE9ETyBmaXggdGVzdHMgdG8gd29ya3Mgd2l0aCBzbWFsbGNhcHMuKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J2NhcGRhdGEnfSk7XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3Qgc3RyaW5naWZ5PSh2YWwpPT5zZXJpYWxpemUodmFsKS5ib2R5OyRozY9fb25jZS5zdHJpbmdpZnkoc3RyaW5naWZ5KTtcbmhhcmRlbihzdHJpbmdpZnkpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJcbiAqIEByZXR1cm5zIHt1bmtub3dufVxuICovXG5jb25zdCBwYXJzZT0oc3RyKT0+XG51bnNlcmlhbGl6ZShcbmhhcmRlbih7XG5ib2R5OnN0cixcbnNsb3RzOmJhZEFycmF5fSkpOyRozY9fb25jZS5wYXJzZShwYXJzZSk7XG5cblxuaGFyZGVuKHBhcnNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0cmluZ2lmeSI6WyJzdHJpbmdpZnkiXSwicGFyc2UiOlsicGFyc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAE7Fc3pk3AACZNwAAIwAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLmpzeyJpbXBvcnRzIjpbIkBlbmRvL25hdCIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9lcnJvcnMiLCJAZW5kby9jb21tb24vb2JqZWN0LW1hcC5qcyIsIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9lbmNvZGVUb1NtYWxsY2Fwcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VNYXJzaGFsIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IE5hdCxhc3NlcnRQYXNzYWJsZSxnZXRJbnRlcmZhY2VPZixnZXRFcnJvckNvbnN0cnVjdG9yLGhhc093blByb3BlcnR5T2YsdG9QYXNzYWJsZUVycm9yLFgsRmFpbCxxLG1ha2VFcnJvcixhbm5vdGF0ZUVycm9yLG9iamVjdE1hcCxRQ0xBU1MsbWFrZUVuY29kZVRvQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbUNhcERhdGEsbWFrZURlY29kZUZyb21TbWFsbGNhcHMsbWFrZUVuY29kZVRvU21hbGxjYXBzOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRozY9fYSA9PiAoTmF0ID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaM2PX2EpXV0sW1wiZ2V0SW50ZXJmYWNlT2ZcIiwgWyRozY9fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJ0b1Bhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAodG9QYXNzYWJsZUVycm9yID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJtYWtlRXJyb3JcIiwgWyRozY9fYSA9PiAobWFrZUVycm9yID0gJGjNj19hKV1dLFtcImFubm90YXRlRXJyb3JcIiwgWyRozY9fYSA9PiAoYW5ub3RhdGVFcnJvciA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2NvbW1vbi9vYmplY3QtbWFwLmpzXCIsIFtbXCJvYmplY3RNYXBcIiwgWyRozY9fYSA9PiAob2JqZWN0TWFwID0gJGjNj19hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjNj19hID0+IChRQ0xBU1MgPSAkaM2PX2EpXV0sW1wibWFrZUVuY29kZVRvQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRW5jb2RlVG9DYXBEYXRhID0gJGjNj19hKV1dLFtcIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YVwiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbUNhcERhdGEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVRvU21hbGxjYXBzLmpzXCIsIFtbXCJtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwc1wiLCBbJGjNj19hID0+IChtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyA9ICRozY9fYSldXSxbXCJtYWtlRW5jb2RlVG9TbWFsbGNhcHNcIiwgWyRozY9fYSA9PiAobWFrZUVuY29kZVRvU21hbGxjYXBzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDb252ZXJ0U2xvdFRvVmFsLCBDb252ZXJ0VmFsVG9TbG90LCBGcm9tQ2FwRGF0YSwgTWFrZU1hcnNoYWxPcHRpb25zLCBUb0NhcERhdGF9IGZyb20gJy4vdHlwZXMuanMnO1xuICogQGltcG9ydCB7UGFzc2FibGUsIFBhc3NhYmxlQ2FwLCBSZW1vdGFibGVPYmplY3R9IGZyb20gJ0BlbmRvL3Bhc3Mtc3R5bGUnO1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlY30gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSc7XG4gKiBAaW1wb3J0IHtFbmNvZGluZ30gZnJvbSAnLi90eXBlcy5qcyc7XG4gKi9cblxuY29uc3R7ZGVmaW5lUHJvcGVydGllc309T2JqZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge0NvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRWYWxUb1Nsb3RGbj0oeCk9Png7XG4vKiogQHR5cGUge0NvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRTbG90VG9WYWxGbj0oeCxfKT0+eDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgU2xvdFxuICogQHBhcmFtIHtDb252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBbY29udmVydFZhbFRvU2xvdF1cbiAqIEBwYXJhbSB7Q29udmVydFNsb3RUb1ZhbDxTbG90Pn0gW2NvbnZlcnRTbG90VG9WYWxdXG4gKiBAcGFyYW0ge01ha2VNYXJzaGFsT3B0aW9uc30gb3B0aW9uc1xuICovXG5jb25zdCAgICAgICAgbWFrZU1hcnNoYWw9KFxuY29udmVydFZhbFRvU2xvdD1kZWZhdWx0VmFsVG9TbG90Rm4sXG5jb252ZXJ0U2xvdFRvVmFsPWRlZmF1bHRTbG90VG9WYWxGbixcbntcbmVycm9yVGFnZ2luZz0nb24nLFxubWFyc2hhbE5hbWU9J2Fub24tbWFyc2hhbCcsXG4vKiBUT0RPIFRlbXBvcmFyeSBoYWNrLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8yNzgwKi9cbmVycm9ySWROdW09MTAwMDAsXG4vKiBXZSBwcmVmZXIgdGhhdCB0aGUgY2FsbGVyIGluc3RlYWQgbG9nIHRvIHNvbWV3aGVyZSBoaWRkZW4qL1xuLyogdG8gYmUgcmV2ZWFsZWQgd2hlbiBjb3JyZWxhdGluZyB3aXRoIHRoZSByZWNlaXZlZCBlcnJvci4qL1xubWFyc2hhbFNhdmVFcnJvcj0oZXJyKT0+XG5jb25zb2xlLmxvZygnVGVtcG9yYXJ5IGxvZ2dpbmcgb2Ygc2VudCBlcnJvcicsZXJyKSxcbi8qIERlZmF1bHQgdG8gJ2NhcGRhdGEnIGJlY2F1c2UgaXQgd2FzIGltcGxlbWVudGVkIGZpcnN0LiovXG4vKiBTb21ldGltZXMsIG9udG9nZW55IGRvZXMgcmVjYXBpdHVsYXRlIHBoeWxvZ2VueSA7KSovXG5zZXJpYWxpemVCb2R5Rm9ybWF0PSdjYXBkYXRhJ309XG57fSk9Plxue1xuYXNzZXJ0LnR5cGVvZihtYXJzaGFsTmFtZSwnc3RyaW5nJyk7XG5lcnJvclRhZ2dpbmc9PT0nb24nfHxcbmVycm9yVGFnZ2luZz09PSdvZmYnfHxcbkZhaWwgYFRoZSBlcnJvclRhZ2dpbmcgb3B0aW9uIGNhbiBvbmx5IGJlIFwib25cIiBvciBcIm9mZlwiICR7ZXJyb3JUYWdnaW5nfWA7XG5jb25zdCBuZXh0RXJyb3JJZD0oKT0+e1xuZXJyb3JJZE51bSs9MTtcbnJldHVybiBgZXJyb3I6JHttYXJzaGFsTmFtZX0jJHtlcnJvcklkTnVtfWA7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7VG9DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCB0b0NhcERhdGE9KHJvb3QpPT57XG5jb25zdCBzbG90cz1bXTtcbi8qIG1hcHMgdmFsIChwcm9taXNlIG9yIHJlbW90YWJsZSkgdG8gaW5kZXggb2Ygc2xvdHNbXSovXG5jb25zdCBzbG90TWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHJldHVybnMge3tpbmRleDogbnVtYmVyLCByZXBlYXQ6IGJvb2xlYW59fVxuICovXG5jb25zdCBlbmNvZGVTbG90Q29tbW9uPShwYXNzYWJsZSk9PntcbmxldCBpbmRleD1zbG90TWFwLmdldChwYXNzYWJsZSk7XG5pZihpbmRleCE9PXVuZGVmaW5lZCl7XG4vKiBUT0RPIGFzc2VydCB0aGF0IGl0J3MgdGhlIHNhbWUgaWZhY2UgYXMgYmVmb3JlKi9cbmFzc2VydC50eXBlb2YoaW5kZXgsJ251bWJlcicpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OnRydWV9KTtcbiB9XG5cbmluZGV4PXNsb3RzLmxlbmd0aDtcbmNvbnN0IHNsb3Q9Y29udmVydFZhbFRvU2xvdChwYXNzYWJsZSk7XG5zbG90cy5wdXNoKHNsb3QpO1xuc2xvdE1hcC5zZXQocGFzc2FibGUsaW5kZXgpO1xucmV0dXJuIGhhcmRlbih7aW5kZXgscmVwZWF0OmZhbHNlfSk7XG4gfTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiB1bmtub3dufSBlbmNvZGVSZWN1clxuICogQHJldHVybnMge3tlcnJvcklkPzogc3RyaW5nLCBtZXNzYWdlOiBzdHJpbmcsIG5hbWU6IHN0cmluZ319XG4gKi9cbmNvbnN0IGVuY29kZUVycm9yQ29tbW9uPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBtZXNzYWdlPWVuY29kZVJlY3VyKCBgJHtlcnIubWVzc2FnZX1gKTtcbmFzc2VydC50eXBlb2YobWVzc2FnZSwnc3RyaW5nJyk7XG5jb25zdCBuYW1lPWVuY29kZVJlY3VyKCBgJHtlcnIubmFtZX1gKTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG4vKiBUT0RPIE11c3QgZW5jb2RlIGBjYXVzZWAsIGBlcnJvcnNgLCBidXQqL1xuLyogb25seSBvbmNlIGFsbCBwb3NzaWJsZSBjb3VudGVycGFydHkgZGVjb2RlcnMgYXJlIHRvbGVyYW50IG9mKi9cbi8qIHJlY2VpdmluZyB0aGVtLiovXG5pZihlcnJvclRhZ2dpbmc9PT0nb24nKXtcbi8qIFdlIGRlbGliZXJhdGVseSBkbyBub3Qgc2hhcmUgdGhlIHN0YWNrLCBidXQgaXQgd291bGQqL1xuLyogYmUgdXNlZnVsIHRvIGxvZyB0aGUgc3RhY2sgbG9jYWxseSBzbyBzb21lb25lIHdobyBoYXMqL1xuLyogcHJpdmlsZWdlZCBhY2Nlc3MgdG8gdGhlIHRocm93aW5nIFZhdCBjYW4gY29ycmVsYXRlKi9cbi8qIHRoZSBwcm9ibGVtIHdpdGggdGhlIHJlbW90ZSBWYXQgdGhhdCBnZXRzIHRoaXMqL1xuLyogc3VtbWFyeS4gSWYgd2UgZG8gdGhhdCwgd2UgY291bGQgYWxsb2NhdGUgc29tZSByYW5kb20qL1xuLyogaWRlbnRpZmllciBhbmQgaW5jbHVkZSBpdCBpbiB0aGUgbWVzc2FnZSwgdG8gaGVscCovXG4vKiB3aXRoIHRoZSBjb3JyZWxhdGlvbi4qL1xuY29uc3QgZXJyb3JJZD1lbmNvZGVSZWN1cihuZXh0RXJyb3JJZCgpKTtcbmFzc2VydC50eXBlb2YoZXJyb3JJZCwnc3RyaW5nJyk7XG5hbm5vdGF0ZUVycm9yKGVycixYIGBTZW50IGFzICR7ZXJyb3JJZH1gKTtcbm1hcnNoYWxTYXZlRXJyb3IoZXJyKTtcbnJldHVybiBoYXJkZW4oe2Vycm9ySWQsbWVzc2FnZSxuYW1lfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHttZXNzYWdlLG5hbWV9KTtcbiB9XG4gfTtcblxuaWYoc2VyaWFsaXplQm9keUZvcm1hdD09PSdjYXBkYXRhJyl7XG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVDYXB9IHBhc3NhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV1cbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlU2xvdFRvQ2FwRGF0YT0ocGFzc2FibGUsaWZhY2U9dW5kZWZpbmVkKT0+e1xuY29uc3R7aW5kZXgscmVwZWF0fT1lbmNvZGVTbG90Q29tbW9uKHBhc3NhYmxlKTtcblxuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J3Nsb3QnLGluZGV4fSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtbUUNMQVNTXTonc2xvdCcsaWZhY2UsaW5kZXh9KTtcbiB9XG4gfTtcblxuLyoqIEB0eXBlIHsocHJvbWlzZTogUmVtb3RhYmxlT2JqZWN0LCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHZhbCxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb0NhcERhdGEodmFsLGdldEludGVyZmFjZU9mKHZhbCkpO1xuXG4vKiogQHR5cGUgeyhwcm9taXNlOiBQcm9taXNlLCBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZykgPT4gRW5jb2Rpbmd9ICovXG5jb25zdCBlbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9taXNlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YShwcm9taXNlKTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ30gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidlcnJvcicsLi4uZXJyRGF0YX0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvQ2FwRGF0YT1tYWtlRW5jb2RlVG9DYXBEYXRhKHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IGVuY29kZWQ9ZW5jb2RlVG9DYXBEYXRhKHJvb3QpO1xuY29uc3QgYm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuYm9keSxcbnNsb3RzfSk7XG5cbiB9ZWxzZSBpZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J3NtYWxsY2Fwcycpe1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcHJlZml4XG4gKiBAcGFyYW0ge1Bhc3NhYmxlQ2FwfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9TbWFsbGNhcHM9KHByZWZpeCxwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG4vKiBUT0RPIGV4cGxvcmUgcmVtb3ZpbmcgdGhpcyBzcGVjaWFsIGNhc2UqL1xuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fWA7XG4gfVxucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fS4ke2lmYWNlfWA7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbW90YWJsZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJCcscmVtb3RhYmxlLGdldEludGVyZmFjZU9mKHJlbW90YWJsZSkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9TbWFsbGNhcHMoJyYnLHByb21pc2UpO1xuXG5jb25zdCBlbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBlcnJEYXRhPWVuY29kZUVycm9yQ29tbW9uKGVycixlbmNvZGVSZWN1cik7XG5jb25zdHttZXNzYWdlLC4uLnJlc3R9PWVyckRhdGE7XG5yZXR1cm4gaGFyZGVuKHsnI2Vycm9yJzptZXNzYWdlLC4uLnJlc3R9KTtcbiB9O1xuXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwcz1tYWtlRW5jb2RlVG9TbWFsbGNhcHMoe1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb1NtYWxsY2Fwcyhyb290KTtcbmNvbnN0IHNtYWxsY2Fwc0JvZHk9SlNPTi5zdHJpbmdpZnkoZW5jb2RlZCk7XG5yZXR1cm4gaGFyZGVuKHtcbi8qIFZhbGlkIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYSB2YWxpZCBzaWduYWwqL1xuLyogaW5kaWNhdGluZyBzbWFsbGNhcHMgZm9ybWF0LiovXG5ib2R5OiBgIyR7c21hbGxjYXBzQm9keX1gLFxuc2xvdHN9KTtcblxuIH1lbHNle1xuLyogVGhlIGB0aHJvd2AgaXMgYSBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEFkZGVkIGZvciBjb25mdXNlZCBsaW50ZXJzLiovXG50aHJvdyBGYWlsIGBVbnJlY29nbml6ZWQgc2VyaWFsaXplQm9keUZvcm1hdDogJHtxKHNlcmlhbGl6ZUJvZHlGb3JtYXQpfWA7XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VGdWxsUmV2aXZlPShzbG90cyk9Pntcbi8qKiBAdHlwZSB7TWFwPG51bWJlciwgUmVtb3RhYmxlT2JqZWN0IHwgUHJvbWlzZT59ICovXG5jb25zdCB2YWxNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7e2lmYWNlPzogc3RyaW5nLCBpbmRleDogbnVtYmVyfX0gc2xvdERhdGFcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5jb25zdCBkZWNvZGVTbG90Q29tbW9uPShzbG90RGF0YSk9PntcbmNvbnN0e2lmYWNlPXVuZGVmaW5lZCxpbmRleCwuLi5yZXN0fT1zbG90RGF0YTtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgc2xvdCBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuY29uc3QgZXh0YW50PXZhbE1hcC5nZXQoaW5kZXgpO1xuaWYoZXh0YW50KXtcbnJldHVybiBleHRhbnQ7XG4gfVxuLyogVE9ETyBTRUNVUklUWSBIQVpBUkQ6IG11c3QgZW5mb2NlIHRoYXQgcmVtb3RhYmxlIHZzIHByb21pc2UqL1xuLyogaXMgYWNjb3JkaW5nIHRvIHRoZSBlbmNvZGVkIHN0cmluZy4qL1xuY29uc3Qgc2xvdD1zbG90c1tOdW1iZXIoTmF0KGluZGV4KSldO1xuY29uc3QgdmFsPWNvbnZlcnRTbG90VG9WYWwoc2xvdCxpZmFjZSk7XG52YWxNYXAuc2V0KGluZGV4LHZhbCk7XG5yZXR1cm4gdmFsO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHt7XG4gKiAgIGVycm9ySWQ/OiBzdHJpbmcsXG4gKiAgIG1lc3NhZ2U6IHN0cmluZyxcbiAqICAgbmFtZTogc3RyaW5nLFxuICogICBjYXVzZTogdW5rbm93bixcbiAqICAgZXJyb3JzOiB1bmtub3duLFxuICogfX0gZXJyRGF0YVxuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IGRlY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0IGRlY29kZUVycm9yQ29tbW9uPShlcnJEYXRhLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7XG5lcnJvcklkPXVuZGVmaW5lZCxcbm1lc3NhZ2UsXG5uYW1lLFxuY2F1c2U9dW5kZWZpbmVkLFxuZXJyb3JzPXVuZGVmaW5lZCxcbi4uLnJlc3R9PVxuZXJyRGF0YTtcbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8yMDUyKi9cbi8qIGNhcERhdGEgZG9lcyBub3QgdHJhbnNmb3JtIHN0cmluZ3MuIFRoZSBpbW1lZGlhdGVseSBmb2xsb3dpbmcgY2FsbHMqL1xuLyogdG8gYGRlY29kZVJlY3VyYCBhcmUgZm9yIHJldXNlIGJ5IG90aGVyIGVuY29kaW5ncyB0aGF0IGRvLCovXG4vKiBzdWNoIGFzIHNtYWxsY2Fwcy4qL1xuY29uc3QgZE5hbWU9ZGVjb2RlUmVjdXIobmFtZSk7XG5jb25zdCBkTWVzc2FnZT1kZWNvZGVSZWN1cihtZXNzYWdlKTtcbi8qIGVycm9ySWQgaXMgYSBsYXRlIGFkZGl0aW9uIHNvIGJlIHRvbGVyYW50IG9mIGl0cyBhYnNlbmNlLiovXG5jb25zdCBkRXJyb3JJZD0vKiogQHR5cGUge3N0cmluZ30gKi9lcnJvcklkJiZkZWNvZGVSZWN1cihlcnJvcklkKTtcbmlmKHR5cGVvZiBkTmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBkTmFtZSl9YDtcbiB9XG5pZih0eXBlb2YgZE1lc3NhZ2UhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgZE1lc3NhZ2UpfWA7XG4gfVxuY29uc3QgZXJyQ29uc3RydWN0b3I9Z2V0RXJyb3JDb25zdHJ1Y3RvcihkTmFtZSl8fEVycm9yO1xuY29uc3QgZXJyb3JOYW1lPVxuZEVycm9ySWQ9PT11bmRlZmluZWQ/XG4gYFJlbW90ZSR7ZXJyQ29uc3RydWN0b3IubmFtZX1gOlxuIGBSZW1vdGUke2VyckNvbnN0cnVjdG9yLm5hbWV9KCR7ZEVycm9ySWR9KWA7XG5jb25zdCBvcHRpb25zPXtcbmVycm9yTmFtZSxcbnNhbml0aXplOmZhbHNlfTtcblxuaWYoY2F1c2Upe1xub3B0aW9ucy5jYXVzZT1kZWNvZGVSZWN1cihjYXVzZSk7XG4gfVxuaWYoZXJyb3JzKXtcbm9wdGlvbnMuZXJyb3JzPWRlY29kZVJlY3VyKGVycm9ycyk7XG4gfVxuY29uc3QgcmF3RXJyb3I9bWFrZUVycm9yKGRNZXNzYWdlLGVyckNvbnN0cnVjdG9yLG9wdGlvbnMpO1xuLyogTm90ZSB0aGF0IHRoaXMgZG9lcyBub3QgZGVjb2RlUmVjdXIgcmVzdCdzIHByb3BlcnR5IG5hbWVzLiovXG4vKiBUaGlzIHdvdWxkIGJlIGluY29uc2lzdGVudCB3aXRoIHNtYWxsY2FwcycgZXhwZWN0ZWQgaGFuZGxpbmcsKi9cbi8qIGJ1dCBpcyBmaW5lIGhlcmUgc2luY2UgaXQgaXMgb25seSB1c2VkIGZvciBgYW5ub3RhdGVFcnJvcmAsKi9cbi8qIHdoaWNoIGlzIGZvciBkaWFnbm9zdGljIGluZm8gdGhhdCBpcyBvdGhlcndpc2UgdW5vYnNlcnZhYmxlLiovXG5jb25zdCBkZXNjcz1vYmplY3RNYXAocmVzdCwoZGF0YSk9Pih7XG52YWx1ZTpkZWNvZGVSZWN1cihkYXRhKSxcbndyaXRhYmxlOmZhbHNlLFxuZW51bWVyYWJsZTpmYWxzZSxcbmNvbmZpZ3VyYWJsZTpmYWxzZX0pKTtcblxuZGVmaW5lUHJvcGVydGllcyhyYXdFcnJvcixkZXNjcyk7XG5oYXJkZW4ocmF3RXJyb3IpO1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcihyYXdFcnJvcik7XG4gfTtcblxuLyogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaCovXG4vKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb24qL1xuLyogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUqL1xuLyogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNCovXG5jb25zdCBkZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0ocmF3VHJlZSxfZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLnNsb3REYXRhfT1yYXdUcmVlO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oc2xvdERhdGEpO1xuIH07XG5cbmNvbnN0IGRlY29kZUVycm9yRnJvbUNhcERhdGE9KHJhd1RyZWUsZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLmVyckRhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlRXJyb3JDb21tb24oZXJyRGF0YSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbUNhcERhdGE9bWFrZURlY29kZUZyb21DYXBEYXRhKHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IG1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2Fwcz0ocHJlZml4KT0+e1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyaW5nRW5jb2RpbmdcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBfZGVjb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtSZW1vdGFibGVPYmplY3QgfCBQcm9taXNlfVxuICovXG5yZXR1cm4oc3RyaW5nRW5jb2RpbmcsX2RlY29kZVJlY3VyKT0+e1xuYXNzZXJ0KHN0cmluZ0VuY29kaW5nLmNoYXJBdCgwKT09PXByZWZpeCk7XG4vKiBzbG90czogJHNsb3RJbmRleC5pZmFjZSBvciAkc2xvdEluZGV4Ki9cbmNvbnN0IGk9c3RyaW5nRW5jb2RpbmcuaW5kZXhPZignLicpO1xuY29uc3QgaW5kZXg9TnVtYmVyKHN0cmluZ0VuY29kaW5nLnNsaWNlKDEsaTwwP3VuZGVmaW5lZDppKSk7XG4vKiBpIDwgMCBtZWFucyB0aGVyZSB3YXMgbm8gaWZhY2UgaW5jbHVkZWQuKi9cbmNvbnN0IGlmYWNlPWk8MD91bmRlZmluZWQ6c3RyaW5nRW5jb2Rpbmcuc2xpY2UoaSsxKTtcbnJldHVybiBkZWNvZGVTbG90Q29tbW9uKHtpZmFjZSxpbmRleH0pO1xuIH07XG4gfTtcbmNvbnN0IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzKCckJyk7XG5jb25zdCBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyYnKTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyxkZWNvZGVSZWN1cik9PntcbmNvbnN0eycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdEVyckRhdGF9PWVuY29kaW5nO1xuIWhhc093blByb3BlcnR5T2YocmVzdEVyckRhdGEsJ21lc3NhZ2UnKXx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgZXJyb3IgcHJvcGVydHkgJHtxKCdtZXNzYWdlJyl9YDtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbih7bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX0sZGVjb2RlUmVjdXIpO1xuIH07XG5cbmNvbnN0IHJldml2ZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZUZyb21TbWFsbGNhcHMoe1xuLyogQHRzLWlnbm9yZSBYWFggU21hbGxDYXBzRW5jb2RpbmcqL1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcyxcbi8qIEB0cy1pZ25vcmUgWFhYIFNtYWxsQ2Fwc0VuY29kaW5nKi9cbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc30pO1xuIH07XG5cbi8qKlxuICogQHR5cGUge0Zyb21DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCBmcm9tQ2FwRGF0YT0oZGF0YSk9PntcbmNvbnN0e2JvZHksc2xvdHN9PWRhdGE7XG50eXBlb2YgYm9keT09PSdzdHJpbmcnfHxcbkZhaWwgYHVuc2VyaWFsaXplKCkgZ2l2ZW4gbm9uLWNhcGRhdGEgKC5ib2R5IGlzICR7Ym9keX0sIG5vdCBzdHJpbmcpYDtcbmlzQXJyYXkoZGF0YS5zbG90cyl8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLnNsb3RzIGFyZSBub3QgQXJyYXkpYDtcbmNvbnN0e3Jldml2ZUZyb21DYXBEYXRhLHJldml2ZUZyb21TbWFsbGNhcHN9PW1ha2VGdWxsUmV2aXZlKHNsb3RzKTtcbmxldCByZXN1bHQ7XG4vKiBKU09OIGNhbm5vdCBiZWdpbiB3aXRoIGEgJyMnLCBzbyB0aGlzIGlzIGFuIHVuYW1iaWd1b3VzIHNpZ25hbC4qL1xuaWYoYm9keS5jaGFyQXQoMCk9PT0nIycpe1xuY29uc3Qgc21hbGxjYXBzQm9keT1ib2R5LnNsaWNlKDEpO1xuY29uc3QgZW5jb2Rpbmc9aGFyZGVuKEpTT04ucGFyc2Uoc21hbGxjYXBzQm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tU21hbGxjYXBzKGVuY29kaW5nKSk7XG4gfWVsc2V7XG5jb25zdCByYXdUcmVlPWhhcmRlbihKU09OLnBhcnNlKGJvZHkpKTtcbnJlc3VsdD1oYXJkZW4ocmV2aXZlRnJvbUNhcERhdGEocmF3VHJlZSkpO1xuIH1cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzcqL1xuLyogd2hpY2ggc2hvdWxkIGJlIGNvbnNpZGVyZWQgZml4ZWQgb25jZSB3ZSd2ZSBjb21wbGV0ZWQgdGhlIHN3aXRjaCovXG4vKiB0byBzbWFsbGNhcHMuKi9cbmFzc2VydFBhc3NhYmxlKHJlc3VsdCk7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc2FibGVDYXB9ICovcmVzdWx0KTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtcbnRvQ2FwRGF0YSxcbmZyb21DYXBEYXRhLFxuXG4vKiBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkqL1xuLyoqIEBkZXByZWNhdGVkIHVzZSB0b0NhcERhdGEgKi9cbnNlcmlhbGl6ZTp0b0NhcERhdGEsXG4vKiogQGRlcHJlY2F0ZWQgdXNlIGZyb21DYXBEYXRhICovXG51bnNlcmlhbGl6ZTpmcm9tQ2FwRGF0YX0pO1xuXG4gfTskaM2PX29uY2UubWFrZU1hcnNoYWwobWFrZU1hcnNoYWwpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZU1hcnNoYWwiOlsibWFrZU1hcnNoYWwiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZrtByttBAADbQQAAJQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9yYW5rT3JkZXIuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL2Vycm9ycyIsIi4vZW5jb2RlUGFzc2FibGUuanMiXSwiZXhwb3J0cyI6WyJGdWxsUmFua0NvdmVyIiwiYXNzZXJ0UmFua1NvcnRlZCIsImNvbXBhcmF0b3JNaXJyb3JJbWFnZSIsImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVSYW5rIiwiY292ZXJlZEVudHJpZXMiLCJnZXRJbmRleENvdmVyIiwiZ2V0UGFzc1N0eWxlQ292ZXIiLCJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaXNSYW5rU29ydGVkIiwibWFrZUNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsInNvcnRCeVJhbmsiLCJ0cml2aWFsQ29tcGFyYXRvciIsInVuaW9uUmFua0NvdmVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBnZXRUYWcscGFzc1N0eWxlT2YsbmFtZUZvclBhc3NhYmxlU3ltYm9sLEZhaWwscSxwYXNzU3R5bGVQcmVmaXhlcyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXM7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRozY9fYSA9PiAoZ2V0VGFnID0gJGjNj19hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjNj19hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL2VuY29kZVBhc3NhYmxlLmpzXCIsIFtbXCJwYXNzU3R5bGVQcmVmaXhlc1wiLCBbJGjNj19hID0+IChwYXNzU3R5bGVQcmVmaXhlcyA9ICRozY9fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjNj19hID0+IChyZWNvcmROYW1lcyA9ICRozY9fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRozY9fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUGFzc1N0eWxlfSBmcm9tICdAZW5kby9wYXNzLXN0eWxlJ1xuICogQGltcG9ydCB7RnVsbENvbXBhcmUsIFBhcnRpYWxDb21wYXJlLCBQYXJ0aWFsQ29tcGFyaXNvbiwgUmFua0NvbXBhcmUsIFJhbmtDb3Zlcn0gZnJvbSAnLi90eXBlcy5qcydcbiAqL1xuXG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLHNldFByb3RvdHlwZU9mLGlzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmFua0NvbXBhcmF0b3JLaXRcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGFudGlDb21wYXJhdG9yXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGdWxsQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtbbnVtYmVyLCBudW1iZXJdfSBJbmRleENvdmVyXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBlcXVhbGl0eSBjb21wYXJpc29uIHVzZWQgYnkgSmF2YVNjcmlwdCdzIE1hcCBhbmQgU2V0XG4gKiBhYnN0cmFjdGlvbnMsIHdoZXJlIE5hTiBpcyB0aGUgc2FtZSBhcyBOYU4gYW5kIC0wIGlzIHRoZSBzYW1lIGFzXG4gKiAwLiBNYXJzaGFsIHNlcmlhbGl6ZXMgLTAgYXMgemVybywgc28gdGhlIHNlbWFudGljcyBvZiBvdXIgZGlzdHJpYnV0ZWRcbiAqIG9iamVjdCBzeXN0ZW0gZG9lcyBub3QgZGlzdGluZ3Vpc2ggMCBmcm9tIC0wLlxuICpcbiAqIGBzYW1lVmFsdWVaZXJvYCBpcyB0aGUgRWNtYVNjcmlwdCBzcGVjIG5hbWUgZm9yIHRoaXMgZXF1YWxpdHkgY29tcGFyaXNvbixcbiAqIGJ1dCBUT0RPIHdlIG5lZWQgYSBiZXR0ZXIgbmFtZSBmb3IgdGhlIEFQSS5cbiAqXG4gKiBAcGFyYW0ge2FueX0geFxuICogQHBhcmFtIHthbnl9IHlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzYW1lVmFsdWVaZXJvPSh4LHkpPT54PT09eXx8aXMoeCx5KTtcblxuY29uc3QgICAgICAgIHRyaXZpYWxDb21wYXJhdG9yPShsZWZ0LHJpZ2h0KT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnksIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMqL1xubGVmdDxyaWdodD8tMTpsZWZ0PT09cmlnaHQ/MDoxO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8UGFzc1N0eWxlLCB7IGluZGV4OiBudW1iZXIsIGNvdmVyOiBSYW5rQ292ZXIgfT59IFBhc3NTdHlsZVJhbmtzUmVjb3JkXG4gKi8kaM2PX29uY2UudHJpdmlhbENvbXBhcmF0b3IodHJpdmlhbENvbXBhcmF0b3IpO1xuXG5jb25zdCBwYXNzU3R5bGVSYW5rcz0vKiogQHR5cGUge1Bhc3NTdHlsZVJhbmtzUmVjb3JkfSAqL1xuZnJvbUVudHJpZXMoXG5lbnRyaWVzKHBhc3NTdHlsZVByZWZpeGVzKVxuLyogU29ydCBlbnRyaWVzIGJ5IGFzY2VuZGluZyBwcmVmaXguKi8uXG5zb3J0KChbX2xlZnRTdHlsZSxsZWZ0UHJlZml4ZXNdLFtfcmlnaHRTdHlsZSxyaWdodFByZWZpeGVzXSk9PntcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihsZWZ0UHJlZml4ZXMscmlnaHRQcmVmaXhlcyk7XG4gfSkuXG5tYXAoKFtwYXNzU3R5bGUscHJlZml4ZXNdLGluZGV4KT0+e1xuLyogQ292ZXIgYWxsIHN0cmluZ3MgdGhhdCBzdGFydCB3aXRoIGFueSBjaGFyYWN0ZXIgaW4gYHByZWZpeGVzYCwqL1xuLyogdmVyaWZ5aW5nIHRoYXQgaXQgaXMgc29ydGVkIHNvIHRoYXQgaXMqL1xuLyogYWxsIHMgc3VjaCB0aGF0IHByZWZpeGVzLmF0KDApIOKJpCBzIDwgc3VjY2Vzc29yKHByZWZpeGVzLmF0KC0xKSkuKi9cbnByZWZpeGVzPT09Wy4uLnByZWZpeGVzXS5zb3J0KCkuam9pbignJyl8fFxuRmFpbCBgdW5zb3J0ZWQgcHJlZml4ZXMgZm9yIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7cShwcmVmaXhlcyl9YDtcbmNvbnN0IGNvdmVyPVtcbnByZWZpeGVzLmNoYXJBdCgwKSxcblN0cmluZy5mcm9tQ2hhckNvZGUocHJlZml4ZXMuY2hhckNvZGVBdChwcmVmaXhlcy5sZW5ndGgtMSkrMSldO1xuXG5yZXR1cm5bcGFzc1N0eWxlLHtpbmRleCxjb3Zlcn1dO1xuIH0pKTtcblxuXG5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVSYW5rcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVSYW5rcyk7XG5cbi8qKlxuICogQXNzb2NpYXRlIHdpdGggZWFjaCBwYXNzU3R5bGUgYSBSYW5rQ292ZXIgdGhhdCBtYXkgYmUgYW4gb3ZlcmVzdGltYXRlLFxuICogYW5kIHdob3NlIHJlc3VsdHMgdGhlcmVmb3JlIG5lZWQgdG8gYmUgZmlsdGVyZWQgZG93bi4gRm9yIGV4YW1wbGUsIGJlY2F1c2VcbiAqIHRoZXJlIGlzIG5vdCBhIHNtYWxsZXN0IG9yIGJpZ2dlc3QgYmlnaW50LCBib3VuZCBpdCBieSBgTmFOYCAodGhlIGxhc3QgcGxhY2VcbiAqIG51bWJlcikgYW5kIGAnJ2AgKHRoZSBlbXB0eSBzdHJpbmcsIHdoaWNoIGlzIHRoZSBmaXJzdCBwbGFjZSBzdHJpbmcpLiBUaHVzLFxuICogYSByYW5nZSBxdWVyeSB1c2luZyB0aGlzIHJhbmdlIG1heSBpbmNsdWRlIHRoZXNlIHZhbHVlcywgd2hpY2ggd291bGQgdGhlblxuICogbmVlZCB0byBiZSBmaWx0ZXJlZCBvdXQuXG4gKlxuICogQHBhcmFtIHtQYXNzU3R5bGV9IHBhc3NTdHlsZVxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldFBhc3NTdHlsZUNvdmVyPShwYXNzU3R5bGUpPT5wYXNzU3R5bGVSYW5rc1twYXNzU3R5bGVdLmNvdmVyOyRozY9fb25jZS5nZXRQYXNzU3R5bGVDb3ZlcihnZXRQYXNzU3R5bGVDb3Zlcik7XG5oYXJkZW4oZ2V0UGFzc1N0eWxlQ292ZXIpO1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPFJhbmtDb21wYXJlLFdlYWtTZXQ8UGFzc2FibGVbXT4+fVxuICovXG5jb25zdCBtZW1vT2ZTb3J0ZWQ9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxSYW5rQ29tcGFyZT59XG4gKi9cbmNvbnN0IGNvbXBhcmF0b3JNaXJyb3JJbWFnZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhcnRpYWxDb21wYXJlfSBbY29tcGFyZVJlbW90YWJsZXNdXG4gKiBBIGNvbXBhcmF0b3IgZm9yIGFzc2lnbmluZyBhbiBpbnRlcm5hbCBvcmRlciB0byByZW1vdGFibGVzLlxuICogSXQgZGVmYXVsdHMgdG8gYSBmdW5jdGlvbiB0aGF0IGFsd2F5cyByZXR1cm5zIGBOYU5gLCBtZWFuaW5nIHRoYXQgYWxsXG4gKiByZW1vdGFibGVzIGFyZSBpbmNvbXBhcmFibGUgYW5kIHNob3VsZCB0aWUgZm9yIHRoZSBzYW1lIHJhbmsgYnlcbiAqIHNob3J0LWNpcmN1aXRpbmcgd2l0aG91dCBmdXJ0aGVyIHJlZmluZW1lbnQgKGUuZy4sIG5vdCBvbmx5IGFyZSBgcjFgIGFuZCBgcjJgXG4gKiB0aWVkLCBidXQgc28gYXJlIGBbcjEsIDBdYCBhbmQgYFtyMiwgXCJ4XCJdYCkuXG4gKiBAcmV0dXJucyB7UmFua0NvbXBhcmF0b3JLaXR9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29tcGFyYXRvcktpdD0oY29tcGFyZVJlbW90YWJsZXM9KF94LF95KT0+TmFOKT0+e1xuLyoqIEB0eXBlIHtQYXJ0aWFsQ29tcGFyZX0gKi9cbmNvbnN0IGNvbXBhcmF0b3I9KGxlZnQscmlnaHQpPT57XG5pZihzYW1lVmFsdWVaZXJvKGxlZnQscmlnaHQpKXtcbnJldHVybiAwO1xuIH1cbmNvbnN0IGxlZnRTdHlsZT1wYXNzU3R5bGVPZihsZWZ0KTtcbmNvbnN0IHJpZ2h0U3R5bGU9cGFzc1N0eWxlT2YocmlnaHQpO1xuaWYobGVmdFN0eWxlIT09cmlnaHRTdHlsZSl7XG5yZXR1cm4gdHJpdmlhbENvbXBhcmF0b3IoXG5wYXNzU3R5bGVSYW5rc1tsZWZ0U3R5bGVdLmluZGV4LFxucGFzc1N0eWxlUmFua3NbcmlnaHRTdHlsZV0uaW5kZXgpO1xuXG4gfVxuLyogZXNsaW50LWRpc2FibGUgQGVuZG8vcmVzdHJpY3QtY29tcGFyaXNvbi1vcGVyYW5kcyAtLVxuICogV2Uga25vdyBgbGVmdGAgYW5kIGByaWdodGAgYXJlIGNvbXBhcmFibGUuXG4gKi9cbnN3aXRjaChsZWZ0U3R5bGUpe1xuY2FzZSdyZW1vdGFibGUnOntcbnJldHVybiBjb21wYXJlUmVtb3RhYmxlcyhsZWZ0LHJpZ2h0KTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ251bGwnOlxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbi8qIEZvciBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIGFsbCBtZW1iZXJzIG9mIHRoYXQgcGFzc1N0eWxlIGFyZSB0aWVkKi9cbi8qIGZvciB0aGUgc2FtZSByYW5rLiovXG5yZXR1cm4gMDtcbiB9XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOntcbi8qIFdpdGhpbiBlYWNoIG9mIHRoZXNlIHBhc3NTdHlsZXMsIHRoZSByYW5rIG9yZGVyaW5nIGFncmVlcyB3aXRoKi9cbi8qIEphdmFTY3JpcHQncyByZWxhdGlvbmFsIG9wZXJhdG9ycyBgPGAgYW5kIGA+YC4qL1xuaWYobGVmdDxyaWdodCl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbmFzc2VydChsZWZ0PnJpZ2h0KTtcbnJldHVybiAxO1xuIH1cbiB9XG5jYXNlJ3N5bWJvbCc6e1xucmV0dXJuIGNvbXBhcmF0b3IoXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wobGVmdCksXG5uYW1lRm9yUGFzc2FibGVTeW1ib2wocmlnaHQpKTtcblxuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBgTmFOYCdzIHJhbmsgaXMgYWZ0ZXIgYWxsIG90aGVyIG51bWJlcnMuKi9cbmlmKE51bWJlci5pc05hTihsZWZ0KSl7XG5hc3NlcnQoIU51bWJlci5pc05hTihyaWdodCkpO1xucmV0dXJuIDE7XG4gfWVsc2UgaWYoTnVtYmVyLmlzTmFOKHJpZ2h0KSl7XG5yZXR1cm4tMTtcbiB9XG4vKiBUaGUgcmFuayBvcmRlcmluZyBvZiBub24tTmFOIG51bWJlcnMgYWdyZWVzIHdpdGggSmF2YVNjcmlwdCdzKi9cbi8qIHJlbGF0aW9uYWwgb3BlcmF0b3JzICc8JyBhbmQgJz4nLiovXG5pZihsZWZ0PHJpZ2h0KXtcbnJldHVybi0xO1xuIH1lbHNle1xuYXNzZXJ0KGxlZnQ+cmlnaHQpO1xucmV0dXJuIDE7XG4gfVxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBpbnZlcnNlIHNvcnRlZCBvcmRlciBvZiBwcm9wZXJ0eSBuYW1lcywgdGhlbiovXG4vKiBsZXhpY29ncmFwaGljIGJ5IGNvcnJlc3BvbmRpbmcgdmFsdWVzIGluIHRoYXQgc2FtZSBpbnZlcnNlKi9cbi8qIG9yZGVyIG9mIHRoZWlyIHByb3BlcnR5IG5hbWVzLiBDb21wYXJpbmcgbmFtZXMgYnkgdGhlbXNlbHZlcyBmaXJzdCwqL1xuLyogYWxsIHJlY29yZHMgd2l0aCB0aGUgZXhhY3Qgc2FtZSBzZXQgb2YgcHJvcGVydHkgbmFtZXMgc29ydCBuZXh0IHRvKi9cbi8qIGVhY2ggb3RoZXIgaW4gYSByYW5rLXNvcnQgb2YgY29weVJlY29yZHMuKi9cblxuLyogVGhlIGNvcHlSZWNvcmQgaW52YXJpYW50cyBlbmZvcmNlZCBieSBwYXNzU3R5bGVPZiBlbnN1cmUgdGhhdCovXG4vKiBhbGwgdGhlIHByb3BlcnR5IG5hbWVzIGFyZSBzdHJpbmdzLiBXZSBuZWVkIHRoZSByZXZlcnNlIHNvcnRlZCBvcmRlciovXG4vKiBvZiB0aGVzZSBuYW1lcywgd2hpY2ggd2UgdGhlbiBjb21wYXJlIGxleGljb2dyYXBoaWNhbGx5LiBUaGlzIGVuc3VyZXMqL1xuLyogdGhhdCBpZiB0aGUgbmFtZXMgb2YgcmVjb3JkIFggYXJlIGEgc3Vic2V0IG9mIHRoZSBuYW1lcyBvZiByZWNvcmQgWSwqL1xuLyogdGhlbiByZWNvcmQgWCB3aWxsIGhhdmUgYW4gZWFybGllciByYW5rIGFuZCBzb3J0IHRvIHRoZSBsZWZ0IG9mIFkuKi9cbmNvbnN0IGxlZnROYW1lcz1yZWNvcmROYW1lcyhsZWZ0KTtcbmNvbnN0IHJpZ2h0TmFtZXM9cmVjb3JkTmFtZXMocmlnaHQpO1xuXG5jb25zdCByZXN1bHQ9Y29tcGFyYXRvcihsZWZ0TmFtZXMscmlnaHROYW1lcyk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuY29uc3QgbGVmdFZhbHVlcz1yZWNvcmRWYWx1ZXMobGVmdCxsZWZ0TmFtZXMpO1xuY29uc3QgcmlnaHRWYWx1ZXM9cmVjb3JkVmFsdWVzKHJpZ2h0LHJpZ2h0TmFtZXMpO1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdFZhbHVlcyxyaWdodFZhbHVlcyk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMqL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnRbaV0scmlnaHRbaV0pO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG4vKiBJZiBhbGwgbWF0Y2hpbmcgZWxlbWVudHMgd2VyZSB0aWVkLCB0aGVuIGFjY29yZGluZyB0byB0aGVpciBsZW5ndGhzLiovXG4vKiBJZiBhcnJheSBYIGlzIGEgcHJlZml4IG9mIGFycmF5IFksIHRoZW4gWCBoYXMgYW4gZWFybGllciByYW5rIHRoYW4gWS4qL1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBgW1N5bWJvbC50b1N0cmluZ1RhZ11gIHRoZW4gYC5wYXlsb2FkYC4qL1xuY29uc3QgbGFiZWxDb21wPWNvbXBhcmF0b3IoZ2V0VGFnKGxlZnQpLGdldFRhZyhyaWdodCkpO1xuaWYobGFiZWxDb21wIT09MCl7XG5yZXR1cm4gbGFiZWxDb21wO1xuIH1cbnJldHVybiBjb21wYXJhdG9yKGxlZnQucGF5bG9hZCxyaWdodC5wYXlsb2FkKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBwYXNzU3R5bGU6ICR7cShsZWZ0U3R5bGUpfWA7XG4gfX1cblxuLyogZXNsaW50LWVuYWJsZSAqL1xuIH07XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBvdXRlckNvbXBhcmF0b3I9KHgseSk9PlxuLyogV2hlbiB0aGUgaW5uZXIgY29tcGFyYXRvciByZXR1cm5zIE5hTiB0byBpbmRpY2F0ZSBpbmNvbXBhcmFiaWxpdHksKi9cbi8qIHJlcGxhY2UgdGhhdCB3aXRoIDAgdG8gaW5kaWNhdGUgYSB0aWUuKi9cbi8qKiBAdHlwZSB7RXhjbHVkZTxQYXJ0aWFsQ29tcGFyaXNvbiwgTmFOPn0gKi9jb21wYXJhdG9yKHgseSl8fDA7XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBhbnRpQ29tcGFyYXRvcj0oeCx5KT0+b3V0ZXJDb21wYXJhdG9yKHkseCk7XG5cbm1lbW9PZlNvcnRlZC5zZXQob3V0ZXJDb21wYXJhdG9yLG5ldyBXZWFrU2V0KCkpO1xubWVtb09mU29ydGVkLnNldChhbnRpQ29tcGFyYXRvcixuZXcgV2Vha1NldCgpKTtcbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuc2V0KG91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcik7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChhbnRpQ29tcGFyYXRvcixvdXRlckNvbXBhcmF0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtjb21wYXJhdG9yOm91dGVyQ29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcn0pO1xuIH07XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEByZXR1cm5zIHtSYW5rQ29tcGFyZT19XG4gKi8kaM2PX29uY2UubWFrZUNvbXBhcmF0b3JLaXQobWFrZUNvbXBhcmF0b3JLaXQpO1xuY29uc3QgICAgICAgIGNvbXBhcmF0b3JNaXJyb3JJbWFnZT0oY29tcGFyYXRvcik9PlxuY29tcGFyYXRvck1pcnJvckltYWdlcy5nZXQoY29tcGFyYXRvcik7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjNj19vbmNlLmNvbXBhcmF0b3JNaXJyb3JJbWFnZShjb21wYXJhdG9yTWlycm9ySW1hZ2UpO1xuY29uc3QgICAgICAgIGlzUmFua1NvcnRlZD0ocGFzc2FibGVzLGNvbXBhcmUpPT57XG5jb25zdCBzdWJNZW1vT2ZTb3J0ZWQ9bWVtb09mU29ydGVkLmdldChjb21wYXJlKTtcbmFzc2VydChzdWJNZW1vT2ZTb3J0ZWQhPT11bmRlZmluZWQpO1xuaWYoc3ViTWVtb09mU29ydGVkLmhhcyhwYXNzYWJsZXMpKXtcbnJldHVybiB0cnVlO1xuIH1cbmFzc2VydChwYXNzU3R5bGVPZihwYXNzYWJsZXMpPT09J2NvcHlBcnJheScpO1xuZm9yKGxldCBpPTE7aTxwYXNzYWJsZXMubGVuZ3RoO2krPTEpe1xuaWYoY29tcGFyZShwYXNzYWJsZXNbaS0xXSxwYXNzYWJsZXNbaV0pPj0xKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuc3ViTWVtb09mU29ydGVkLmFkZChwYXNzYWJsZXMpO1xucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNSYW5rU29ydGVkKGlzUmFua1NvcnRlZCk7XG5oYXJkZW4oaXNSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UmFua1NvcnRlZD0oc29ydGVkLGNvbXBhcmUpPT5cbmlzUmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSl8fFxuLyogVE9ETyBhc3NlcnQgb24gYnVnIGNvdWxkIGxlYWQgdG8gaW5maW5pdGUgcmVjdXJzaW9uLiBGaXguKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5GYWlsIGBNdXN0IGJlIHJhbmsgc29ydGVkOiAke3NvcnRlZH0gdnMgJHtzb3J0QnlSYW5rKHNvcnRlZCxjb21wYXJlKX1gOyRozY9fb25jZS5hc3NlcnRSYW5rU29ydGVkKGFzc2VydFJhbmtTb3J0ZWQpO1xuaGFyZGVuKGFzc2VydFJhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHBhc3NhYmxlc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgICAgICAgIHNvcnRCeVJhbms9KHBhc3NhYmxlcyxjb21wYXJlKT0+e1xuaWYoQXJyYXkuaXNBcnJheShwYXNzYWJsZXMpKXtcbmhhcmRlbihwYXNzYWJsZXMpO1xuLyogQ2FsbGluZyBpc1JhbmtTb3J0ZWQgZ2l2ZXMgaXQgYSBjaGFuY2UgdG8gZ2V0IG1lbW9pemVkIGZvciovXG4vKiB0aGlzIGBjb21wYXJlYCBmdW5jdGlvbiBldmVuIGlmIGl0IHdhcyBhbHJlYWR5IG1lbW9pemVkIGZvciBhIGRpZmZlcmVudCovXG4vKiBgY29tcGFyZWAgZnVuY3Rpb24uKi9cbmlmKGlzUmFua1NvcnRlZChwYXNzYWJsZXMsY29tcGFyZSkpe1xucmV0dXJuIHBhc3NhYmxlcztcbiB9XG4gfVxuY29uc3QgdW5zb3J0ZWQ9Wy4uLnBhc3NhYmxlc107XG51bnNvcnRlZC5mb3JFYWNoKGhhcmRlbik7XG5jb25zdCBzb3J0ZWQ9dW5zb3J0ZWQuc29ydChjb21wYXJlKTtcbi8qIEZvciByZXZlcnNlIGNvbXBhcmlzb24sIG1vdmUgYHVuZGVmaW5lZGAgdmFsdWVzIGZyb20gdGhlIGVuZCB0byB0aGUgc3RhcnQuKi9cbi8qIE5vdGUgdGhhdCBwYXNzU3R5bGVQcmVmaXhlcyAoQHNlZSB7QGxpbmsgLi9lbmNvZGVQYXNzYWJsZS5qc30pIE1VU1QgTk9UKi9cbi8qIHNvcnQgYW55IGNhdGVnb3J5IGFmdGVyIGB1bmRlZmluZWRgLiovXG5pZihjb21wYXJlKHRydWUsdW5kZWZpbmVkKT4wKXtcbmxldCBpPXNvcnRlZC5sZW5ndGgtMTtcbndoaWxlKGk+PTAmJnNvcnRlZFtpXT09PXVuZGVmaW5lZClpLT0xO1xuY29uc3Qgbj1zb3J0ZWQubGVuZ3RoLWktMTtcbmlmKG4+MCYmbjxzb3J0ZWQubGVuZ3RoKXtcbnNvcnRlZC5jb3B5V2l0aGluKG4sMCk7XG5zb3J0ZWQuZmlsbCgvKiogQHR5cGUge1R9ICovdW5kZWZpbmVkLDAsbik7XG4gfVxuIH1cbmhhcmRlbihzb3J0ZWQpO1xuY29uc3Qgc3ViTWVtb09mU29ydGVkPW1lbW9PZlNvcnRlZC5nZXQoY29tcGFyZSk7XG5hc3NlcnQoc3ViTWVtb09mU29ydGVkIT09dW5kZWZpbmVkKTtcbnN1Yk1lbW9PZlNvcnRlZC5hZGQoc29ydGVkKTtcbnJldHVybiBzb3J0ZWQ7XG4gfTskaM2PX29uY2Uuc29ydEJ5UmFuayhzb3J0QnlSYW5rKTtcbmhhcmRlbihzb3J0QnlSYW5rKTtcblxuLyoqXG4gKiBTZWVcbiAqIGh0dHBzOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0JpbmFyeV9zZWFyY2hfYWxnb3JpdGhtI1Byb2NlZHVyZV9mb3JfZmluZGluZ190aGVfbGVmdG1vc3RfZWxlbWVudFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBrZXlcbiAqIEBwYXJhbSB7KFwibGVmdE1vc3RcIiB8IFwicmlnaHRNb3N0XCIpPX0gYmlhc1xuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmFua1NlYXJjaD0oc29ydGVkLGNvbXBhcmUsa2V5LGJpYXM9J2xlZnRNb3N0Jyk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xubGV0IGxlZnQ9MDtcbmxldCByaWdodD1zb3J0ZWQubGVuZ3RoO1xud2hpbGUobGVmdDxyaWdodCl7XG5jb25zdCBtPU1hdGguZmxvb3IoKGxlZnQrcmlnaHQpLzIpO1xuY29uc3QgY29tcD1jb21wYXJlKHNvcnRlZFttXSxrZXkpO1xuaWYoY29tcDw9LTF8fGNvbXA9PT0wJiZiaWFzPT09J3JpZ2h0TW9zdCcpe1xubGVmdD1tKzE7XG4gfWVsc2V7XG5hc3NlcnQoY29tcD49MXx8Y29tcD09PTAmJmJpYXM9PT0nbGVmdE1vc3QnKTtcbnJpZ2h0PW07XG4gfVxuIH1cbnJldHVybiBiaWFzPT09J2xlZnRNb3N0Jz9sZWZ0OnJpZ2h0LTE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IHJhbmtDb3ZlclxuICogQHJldHVybnMge0luZGV4Q292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbmRleENvdmVyPShzb3J0ZWQsY29tcGFyZSxbbGVmdEtleSxyaWdodEtleV0pPT57XG5hc3NlcnRSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKTtcbmNvbnN0IGxlZnRJbmRleD1yYW5rU2VhcmNoKHNvcnRlZCxjb21wYXJlLGxlZnRLZXksJ2xlZnRNb3N0Jyk7XG5jb25zdCByaWdodEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUscmlnaHRLZXksJ3JpZ2h0TW9zdCcpO1xucmV0dXJuW2xlZnRJbmRleCxyaWdodEluZGV4XTtcbiB9OyRozY9fb25jZS5nZXRJbmRleENvdmVyKGdldEluZGV4Q292ZXIpO1xuaGFyZGVuKGdldEluZGV4Q292ZXIpO1xuXG4vKiogQHR5cGUge1JhbmtDb3Zlcn0gKi9cbmNvbnN0ICAgICAgICBGdWxsUmFua0NvdmVyPWhhcmRlbihbJycsJ3snXSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7SW5kZXhDb3Zlcn0gaW5kZXhDb3ZlclxuICogQHJldHVybnMge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59XG4gKi8kaM2PX29uY2UuRnVsbFJhbmtDb3ZlcihGdWxsUmFua0NvdmVyKTtcbmNvbnN0ICAgICAgICBjb3ZlcmVkRW50cmllcz0oc29ydGVkLFtsZWZ0SW5kZXgscmlnaHRJbmRleF0pPT57XG4vKiogQHR5cGUge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59ICovXG5jb25zdCBpdGVyYWJsZT1oYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmxldCBpPWxlZnRJbmRleDtcbnJldHVybiBoYXJkZW4oe1xubmV4dDooKT0+e1xuaWYoaTw9cmlnaHRJbmRleCl7XG5jb25zdCBlbGVtZW50PXNvcnRlZFtpXTtcbmkrPTE7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTpbaSxlbGVtZW50XSxkb25lOmZhbHNlfSk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTp1bmRlZmluZWQsZG9uZTp0cnVlfSk7XG4gfVxuIH19KTtcblxuIH19KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjNj19vbmNlLmNvdmVyZWRFbnRyaWVzKGNvdmVyZWRFbnRyaWVzKTtcbmhhcmRlbihjb3ZlcmVkRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtYXhSYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKT49MD9hOmI7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtUfSBhXG4gKiBAcGFyYW0ge1R9IGJcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCBtaW5SYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKTw9MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgdW5pb25SYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCB1bmlvblJhbmtDb3ZlclBhaXI9KFtsZWZ0QSxyaWdodEFdLFtsZWZ0QixyaWdodEJdKT0+W1xubWluUmFuayhjb21wYXJlLGxlZnRBLGxlZnRCKSxcbm1heFJhbmsoY29tcGFyZSxyaWdodEEscmlnaHRCKV07XG5cbnJldHVybiBjb3ZlcnMucmVkdWNlKHVuaW9uUmFua0NvdmVyUGFpcixbJ3snLCcnXSk7XG4gfTskaM2PX29uY2UudW5pb25SYW5rQ292ZXJzKHVuaW9uUmFua0NvdmVycyk7XG5oYXJkZW4odW5pb25SYW5rQ292ZXJzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpbnRlcnNlY3RSYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCBpbnRlcnNlY3RSYW5rQ292ZXJQYWlyPShbbGVmdEEscmlnaHRBXSxbbGVmdEIscmlnaHRCXSk9Pltcbm1heFJhbmsoY29tcGFyZSxsZWZ0QSxsZWZ0QiksXG5taW5SYW5rKGNvbXBhcmUscmlnaHRBLHJpZ2h0QildO1xuXG5yZXR1cm4gY292ZXJzLnJlZHVjZShpbnRlcnNlY3RSYW5rQ292ZXJQYWlyLFsnJywneyddKTtcbiB9OyRozY9fb25jZS5pbnRlcnNlY3RSYW5rQ292ZXJzKGludGVyc2VjdFJhbmtDb3ZlcnMpO1xuXG5jb25zdCAgICAgICB7Y29tcGFyYXRvcjpjb21wYXJlUmFuayxhbnRpQ29tcGFyYXRvcjpjb21wYXJlQW50aVJhbmt9PVxubWFrZUNvbXBhcmF0b3JLaXQoKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjb21wYXJhdG9yIGtpdCBpbiB3aGljaCByZW1vdGFibGVzIGFyZSBmdWxseSBvcmRlcmVkXG4gKiBieSB0aGUgb3JkZXIgaW4gd2hpY2ggdGhleSBhcmUgZmlyc3Qgc2VlbiBieSAqdGhpcyogY29tcGFyYXRvciBraXQuXG4gKiBCRVdBUkU6IFRoaXMgaXMgb2JzZXJ2YWJsZSBtdXRhYmxlIHN0YXRlLCBzbyBzdWNoIGEgY29tcGFyYXRvciBraXRcbiAqIHNob3VsZCBuZXZlciBiZSBzaGFyZWQgYW1vbmcgc3Vic3lzdGVtcyB0aGF0IHNob3VsZCBub3QgYmUgYWJsZVxuICogdG8gY29tbXVuaWNhdGUuXG4gKlxuICogTm90ZSB0aGF0IHRoaXMgb3JkZXIgZG9lcyBub3QgbWVldCB0aGUgcmVxdWlyZW1lbnRzIGZvciBzdG9yZVxuICogb3JkZXJpbmcsIHNpbmNlIGl0IGhhcyBubyBtZW1vcnkgb2YgZGVsZXRlZCBrZXlzLlxuICpcbiAqIFRoZXNlIGZ1bGwgb3JkZXIgY29tcGFyYXRvciBraXQgaXMgc3RyaWN0bHkgbW9yZSBwcmVjaXNlIHRoYXQgdGhlXG4gKiByYW5rIG9yZGVyIGNvbXBhcmF0b3Iga2l0cyBhYm92ZS4gQXMgYSByZXN1bHQsIGFueSBhcnJheSB3aGljaCBpc1xuICogc29ydGVkIGJ5IHN1Y2ggYSBmdWxsIG9yZGVyIHdpbGwgcGFzcyB0aGUgaXNSYW5rU29ydGVkIHRlc3Qgd2l0aFxuICogYSBjb3JyZXNwb25kaW5nIHJhbmsgb3JkZXIuXG4gKlxuICogQW4gYXJyYXkgd2hpY2ggaXMgc29ydGVkIGJ5IGEgKmZyZXNoKiBmdWxsIG9yZGVyIGNvbXBhcmF0b3IsIGkuZS4sXG4gKiBvbmUgdGhhdCBoYXMgbm90IHlldCBzZWVuIGFueSByZW1vdGFibGVzLCB3aWxsIG9mIGNvdXJzZSByZW1haW5cbiAqIHNvcnRlZCBieSBhY2NvcmRpbmcgdG8gKnRoYXQqIGZ1bGwgb3JkZXIgY29tcGFyYXRvci4gQW4gYXJyYXkgKm9mXG4gKiBzY2FsYXJzKiBzb3J0ZWQgYnkgYSBmcmVzaCBmdWxsIG9yZGVyIHdpbGwgcmVtYWluIHNvcnRlZCBldmVuXG4gKiBhY2NvcmRpbmcgdG8gYSBuZXcgZnJlc2ggZnVsbCBvcmRlciBjb21wYXJhdG9yLCBzaW5jZSBpdCB3aWxsIHNlZVxuICogdGhlIHJlbW90YWJsZXMgaW4gdGhlIHNhbWUgb3JkZXIgYWdhaW4uIFVuZm9ydHVuYXRlbHksIHRoaXMgaXNcbiAqIG5vdCB0cnVlIG9mIGFycmF5cyBvZiBwYXNzYWJsZXMgaW4gZ2VuZXJhbC5cbiAqXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBsb25nTGl2ZWRcbiAqIEByZXR1cm5zIHtGdWxsQ29tcGFyYXRvcktpdH1cbiAqLyRozY9fb25jZS5jb21wYXJlUmFuayhjb21wYXJlUmFuayk7JGjNj19vbmNlLmNvbXBhcmVBbnRpUmFuayhjb21wYXJlQW50aVJhbmspO1xuY29uc3QgICAgICAgIG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0PShsb25nTGl2ZWQ9ZmFsc2UpPT57XG5sZXQgbnVtU2Vlbj0wO1xuLyogV2hlbiBkeW5hbWljYWxseSBjcmVhdGVkIHdpdGggc2hvcnQgbGlmZXRpbWVzICh0aGUgZGVmYXVsdCkgYSBXZWFrTWFwKi9cbi8qIHdvdWxkIHBlcmZvcm0gcG9vcmx5LCBhbmQgdGhlIGxlYWsgY3JlYXRlZCBieSBhIE1hcCBvbmx5IGxhc3RzIGFzIGxvbmcqL1xuLyogYXMgdGhlIE1hcC4qL1xuY29uc3QgTWFwQ29uc3RydWN0b3I9bG9uZ0xpdmVkP1dlYWtNYXA6TWFwO1xuY29uc3Qgc2Vlbj1uZXcgTWFwQ29uc3RydWN0b3IoKTtcbmNvbnN0IHRhZz0ocik9PntcbmlmKHNlZW4uaGFzKHIpKXtcbnJldHVybiBzZWVuLmdldChyKTtcbiB9XG5udW1TZWVuKz0xO1xuc2Vlbi5zZXQocixudW1TZWVuKTtcbnJldHVybiBudW1TZWVuO1xuIH07XG5jb25zdCBjb21wYXJlUmVtb3RhYmxlcz0oeCx5KT0+Y29tcGFyZVJhbmsodGFnKHgpLHRhZyh5KSk7XG5yZXR1cm4gbWFrZUNvbXBhcmF0b3JLaXQoY29tcGFyZVJlbW90YWJsZXMpO1xuIH07JGjNj19vbmNlLm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KTtcbmhhcmRlbihtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cml2aWFsQ29tcGFyYXRvciI6WyJ0cml2aWFsQ29tcGFyYXRvciJdLCJnZXRQYXNzU3R5bGVDb3ZlciI6WyJnZXRQYXNzU3R5bGVDb3ZlciJdLCJtYWtlQ29tcGFyYXRvcktpdCI6WyJtYWtlQ29tcGFyYXRvcktpdCJdLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiOlsiY29tcGFyYXRvck1pcnJvckltYWdlIl0sImlzUmFua1NvcnRlZCI6WyJpc1JhbmtTb3J0ZWQiXSwiYXNzZXJ0UmFua1NvcnRlZCI6WyJhc3NlcnRSYW5rU29ydGVkIl0sInNvcnRCeVJhbmsiOlsic29ydEJ5UmFuayJdLCJnZXRJbmRleENvdmVyIjpbImdldEluZGV4Q292ZXIiXSwiRnVsbFJhbmtDb3ZlciI6WyJGdWxsUmFua0NvdmVyIl0sImNvdmVyZWRFbnRyaWVzIjpbImNvdmVyZWRFbnRyaWVzIl0sInVuaW9uUmFua0NvdmVycyI6WyJ1bmlvblJhbmtDb3ZlcnMiXSwiaW50ZXJzZWN0UmFua0NvdmVycyI6WyJpbnRlcnNlY3RSYW5rQ292ZXJzIl0sImNvbXBhcmVSYW5rIjpbImNvbXBhcmVSYW5rIl0sImNvbXBhcmVBbnRpUmFuayI6WyJjb21wYXJlQW50aVJhbmsiXSwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiOlsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAIQAAAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAai91qtYLAADWCwAAHgAAAEBlbmRvL25hdC12NS4wLjEzL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiTmF0IiwiaXNOYXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc05hdCwgJ25hbWUnLCB7dmFsdWU6IFwiaXNOYXRcIn0pOyRozY9fb25jZS5pc05hdChpc05hdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KE5hdCwgJ25hbWUnLCB7dmFsdWU6IFwiTmF0XCJ9KTskaM2PX29uY2UuTmF0KE5hdCk7ICAgLyogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMuKi9cbi8qIENvcHlyaWdodCAoQykgMjAxOCBBZ29yaWMqL1xuLyoqL1xuLyogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTsqL1xuLyogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLiovXG4vKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQqL1xuLyoqL1xuLyogaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKi9cbi8qKi9cbi8qIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUqL1xuLyogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLCovXG4vKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4qL1xuLyogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCovXG4vKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4qL1xuXG4vKiBAdHMtY2hlY2sqL1xuXG4vKipcbiAqIElzIGBhbGxlZ2VkTnVtYCBhIG51bWJlciBpbiB0aGUgW2NvbnRpZ3VvdXMgcmFuZ2Ugb2YgZXhhY3RseSBhbmRcbiAqIHVuYW1iaWd1b3VzbHlcbiAqIHJlcHJlc2VudGFibGVdKGh0dHBzOi8vZXNkaXNjdXNzLm9yZy90b3BpYy9tb3JlLW51bWVyaWMtY29uc3RhbnRzLXBsZWFzZS1lc3BlY2lhbGx5LWVwc2lsb24jY29udGVudC0xNClcbiAqICBuYXR1cmFsIG51bWJlcnMgKG5vbi1uZWdhdGl2ZSBpbnRlZ2Vycyk/XG4gKlxuICogVG8gcXVhbGlmeSBgYWxsZWdlZE51bWAgbXVzdCBlaXRoZXIgYmUgYVxuICogbm9uLW5lZ2F0aXZlIGBiaWdpbnRgLCBvciBhIG5vbi1uZWdhdGl2ZSBgbnVtYmVyYCByZXByZXNlbnRpbmcgYW4gaW50ZWdlclxuICogd2l0aGluIHJhbmdlIG9mIFtpbnRlZ2VycyBzYWZlbHkgcmVwcmVzZW50YWJsZSBpblxuICogZmxvYXRpbmcgcG9pbnRdKGh0dHBzOi8vdGMzOS5lcy9lY21hMjYyLyNzZWMtbnVtYmVyLmlzc2FmZWludGVnZXIpLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gYWxsZWdlZE51bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmZ1bmN0aW9uIGlzTmF0KGFsbGVnZWROdW0pe1xuaWYodHlwZW9mIGFsbGVnZWROdW09PT0nYmlnaW50Jyl7XG5yZXR1cm4gYWxsZWdlZE51bT49MDtcbiB9XG5pZih0eXBlb2YgYWxsZWdlZE51bSE9PSdudW1iZXInKXtcbnJldHVybiBmYWxzZTtcbiB9XG5cbnJldHVybiBOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSYmYWxsZWdlZE51bT49MDtcbiB9XG5cbi8qKlxuICogSWYgYGFsbGVnZWROdW1iZXJgIHBhc3NlcyB0aGUgYGlzTmF0YCB0ZXN0LCB0aGVuIHJldHVybiBpdCBhcyBhIGJpZ2ludC5cbiAqIE90aGVyd2lzZSB0aHJvdyBhbiBhcHByb3ByaWF0ZSBlcnJvci5cbiAqXG4gKiBJZiBgYWxsZWdlZE51bWAgaXMgbmVpdGhlciBhIGJpZ2ludCBub3IgYSBudW1iZXIsIGBOYXRgIHRocm93cyBhIGBUeXBlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpZiBpdCBpcyBub3QgYSBbc2FmZWx5XG4gKiByZXByZXNlbnRhYmxlXShodHRwczovL2VzZGlzY3Vzcy5vcmcvdG9waWMvbW9yZS1udW1lcmljLWNvbnN0YW50cy1wbGVhc2UtZXNwZWNpYWxseS1lcHNpbG9uI2NvbnRlbnQtMTQpXG4gKiBub24tbmVnYXRpdmUgaW50ZWdlciwgYE5hdGAgdGhyb3dzIGEgYFJhbmdlRXJyb3JgLlxuICogT3RoZXJ3aXNlLCBpdCBpcyBjb252ZXJ0ZWQgdG8gYSBiaWdpbnQgaWYgbmVjZXNzYXJ5IGFuZCByZXR1cm5lZC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGFsbGVnZWROdW1cbiAqIEByZXR1cm5zIHtiaWdpbnR9XG4gKi9cbmZ1bmN0aW9uIE5hdChhbGxlZ2VkTnVtKXtcbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J2JpZ2ludCcpe1xuaWYoYWxsZWdlZE51bTwwKXtcbnRocm93IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIGFsbGVnZWROdW07XG4gfVxuXG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdudW1iZXInKXtcbmlmKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSl7XG50aHJvdyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBpcyBub3QgYSBzYWZlIGludGVnZXJgKTtcbiB9XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gaXMgbmVnYXRpdmVgKTtcbiB9XG5yZXR1cm4gQmlnSW50KGFsbGVnZWROdW0pO1xuIH1cblxudGhyb3cgVHlwZUVycm9yKFxuIGAke2FsbGVnZWROdW19IGlzIGEgJHt0eXBlb2YgYWxsZWdlZE51bX0gYnV0IG11c3QgYmUgYSBiaWdpbnQgb3IgYSBudW1iZXJgKTtcblxuIH1cbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzTmF0IjpbImlzTmF0Il0sIk5hdCI6WyJOYXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoSmqvD8KAAA/CgAAIAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvZXJyb3IuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy9zdHJpbmcuanMiLCIuL3NyYy9wYXNzU3R5bGVPZi5qcyIsIi4vc3JjL21ha2VUYWdnZWQuanMiLCIuL3NyYy9tYWtlLWZhci5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiLCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkZhciIsImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSIsImFzc2VydFdlbGxGb3JtZWRTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiLCJpc09iamVjdCIsImlzT2JqZWN0IiwiaXNQYXNzYWJsZSIsImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtbXCIuL3NyYy9pdGVyLWhlbHBlcnMuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9lcnJvci5qc1wiLCBbXV0sW1wiLi9zcmMvcmVtb3RhYmxlLmpzXCIsIFtdXSxbXCIuL3NyYy9zeW1ib2wuanNcIiwgW11dLFtcIi4vc3JjL3N0cmluZy5qc1wiLCBbXV0sW1wiLi9zcmMvcGFzc1N0eWxlT2YuanNcIiwgW11dLFtcIi4vc3JjL21ha2VUYWdnZWQuanNcIiwgW11dLFtcIi4vc3JjL21ha2UtZmFyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlR3VhcmRzLmpzXCIsIFtdXSxbXCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvaXRlci1oZWxwZXJzLmpzIjpbWyJtYXBJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sWyJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIl1dLCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6W1siUEFTU19TVFlMRSIsIlBBU1NfU1RZTEUiXSxbImlzT2JqZWN0IiwiaXNPYmplY3QiXSxbImFzc2VydENoZWNrZXIiLCJhc3NlcnRDaGVja2VyIl0sWyJnZXRUYWciLCJnZXRUYWciXSxbImhhc093blByb3BlcnR5T2YiLCJoYXNPd25Qcm9wZXJ0eU9mIl1dLCIuL3NyYy9lcnJvci5qcyI6W1siZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImdldEVycm9yQ29uc3RydWN0b3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3N0cmluZy5qcyI6W1siaXNXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sWyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyJdLFsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRQYXNzYWJsZVN0cmluZyJdXSwiLi9zcmMvcGFzc1N0eWxlT2YuanMiOltbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXSxbImlzUGFzc2FibGUiLCJpc1Bhc3NhYmxlIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbInRvVGhyb3dhYmxlIiwidG9UaHJvd2FibGUiXV0sIi4vc3JjL21ha2VUYWdnZWQuanMiOltbIm1ha2VUYWdnZWQiLCJtYWtlVGFnZ2VkIl1dLCIuL3NyYy9tYWtlLWZhci5qcyI6W1siUmVtb3RhYmxlIiwiUmVtb3RhYmxlIl0sWyJGYXIiLCJGYXIiXSxbIlRvRmFyRnVuY3Rpb24iLCJUb0ZhckZ1bmN0aW9uIl0sWyJHRVRfTUVUSE9EX05BTUVTIiwiR0VUX01FVEhPRF9OQU1FUyJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAeYB/DAMIAAADCAAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLGFzc2VydENoZWNrZXIsZ2V0T3duRGF0YURlc2NyaXB0b3I7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRozY9fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheSxwcm90b3R5cGU6YXJyYXlQcm90b3R5cGV9PUFycmF5O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0lNUE9SVCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjYW5CZVZhbGlkPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5pc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmY2hlY2soZmFsc2UsWCBgQXJyYXkgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7SU1QT1JUKCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyBnZXQgdG8gZmFpbC4qL1xuY29uc3QgbGVuPS8qKiBAdHlwZSB7bnVtYmVyfSAqL1xuZ2V0T3duRGF0YURlc2NyaXB0b3IoY2FuZGlkYXRlLCdsZW5ndGgnLGZhbHNlLGFzc2VydENoZWNrZXIpLnZhbHVlO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggaW5kZXggcHJvcGVydHkgaXMgb3duL2RhdGEvZW51bWVyYWJsZSovXG4vKiBhbmQgaXRzIGFzc29jaWF0ZWQgdmFsdWUgaXMgcmVjdXJzaXZlbHkgcGFzc2FibGUuKi9cbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSxpLHRydWUsYXNzZXJ0Q2hlY2tlcikudmFsdWUpO1xuXG4gfVxuLyogRXhwZWN0IG9uZSBrZXkgcGVyIGluZGV4IHBsdXMgb25lIGZvciAnbGVuZ3RoJy4qL1xub3duS2V5cyhjYW5kaWRhdGUpLmxlbmd0aD09PWxlbisxfHxcbmFzc2VydC5mYWlsKFggYEFycmF5cyBtdXN0IG5vdCBoYXZlIG5vbi1pbmRleGVzOiAke2NhbmRpZGF0ZX1gLFR5cGVFcnJvcik7XG4gfX0pOyRozY9fb25jZS5Db3B5QXJyYXlIZWxwZXIoQ29weUFycmF5SGVscGVyKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlBcnJheUhlbHBlciI6WyJDb3B5QXJyYXlIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAArHWRoUkKAABJCgAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9jb3B5UmVjb3JkLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJDb3B5UmVjb3JkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGFzc2VydENoZWNrZXIsY2FuQmVNZXRob2QsZ2V0T3duRGF0YURlc2NyaXB0b3IsQ1g7JGjNj19pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiZ2V0T3duRGF0YURlc2NyaXB0b3JcIiwgWyRozY9fYSA9PiAoZ2V0T3duRGF0YURlc2NyaXB0b3IgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0UHJvdG90eXBlT2YscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tPYmplY3RQcm90b3R5cGU9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpPT09b2JqZWN0UHJvdG90eXBlfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZWNvcmRzIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7Y2FuZGlkYXRlfWApO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtQcm9wZXJ0eUtleX0ga2V5XG4gKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqL1xuY29uc3QgY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxrZXksdmFsdWUsY2hlY2s9dW5kZWZpbmVkKT0+e1xucmV0dXJuKFxuKHR5cGVvZiBrZXk9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkmJihcbiFjYW5CZU1ldGhvZCh2YWx1ZSl8fFxuISFjaGVjayYmXG4vKiBUT0RPOiBVcGRhdGUgbWVzc2FnZSBub3cgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIFwiaW1wbGljaXQgUmVtb3RhYmxlXCIuKi9cbkNYKFxuY2hlY2spXG4gYFJlY29yZHMgY2Fubm90IGNvbnRhaW4gbm9uLWZhciBmdW5jdGlvbnMgYmVjYXVzZSB0aGV5IG1heSBiZSBtZXRob2RzIG9mIGFuIGltcGxpY2l0IFJlbW90YWJsZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfTtcblxuLyoqXG4gKlxuICogQHR5cGUge0lNUE9SVCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5yZXR1cm4oXG5jaGVja09iamVjdFByb3RvdHlwZShjYW5kaWRhdGUsY2hlY2spJiZcbi8qIFJlamVjdCBhbnkgY2FuZGlkYXRlIHdpdGggYSBzeW1ib2wta2V5ZWQgcHJvcGVydHkgb3IgbWV0aG9kLWxpa2UgcHJvcGVydHkqL1xuLyogKHN1Y2ggaW5wdXQgaXMgcG90ZW50aWFsbHkgYSBSZW1vdGFibGUpLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkuZXZlcnkoKGtleSk9PlxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLGtleSxjYW5kaWRhdGVba2V5XSxjaGVjaykpKTtcblxuXG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2hlY2tPYmplY3RQcm90b3R5cGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKiBWYWxpZGF0ZSB0aGF0IGVhY2ggb3duIHByb3BlcnR5IGlzIGFwcHJvcHJpYXRlLCBkYXRhL2VudW1lcmFibGUsKi9cbi8qIGFuZCBoYXMgYSByZWN1cnNpdmVseSBwYXNzYWJsZSBhc3NvY2lhdGVkIHZhbHVlLiovXG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY29uc3R7dmFsdWV9PWdldE93bkRhdGFEZXNjcmlwdG9yKFxuY2FuZGlkYXRlLFxubmFtZSxcbnRydWUsXG5hc3NlcnRDaGVja2VyKTtcblxuY2hlY2tQcm9wZXJ0eUNhbkJlVmFsaWQoY2FuZGlkYXRlLG5hbWUsdmFsdWUsYXNzZXJ0Q2hlY2tlcik7XG5wYXNzU3R5bGVPZlJlY3VyKHZhbHVlKTtcbiB9XG4gfX0pOyRozY9fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weVJlY29yZEhlbHBlciI6WyJDb3B5UmVjb3JkSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEHTyCQkFQAAJBUAAC4AAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9wcm9taXNlLWtpdCIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIiwiLi9tYWtlVGFnZ2VkLmpzIl0sImV4cG9ydHMiOlsiZGVlcGx5RnVsZmlsbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IFgscSxFLGlzUHJvbWlzZSxnZXRUYWcsaXNPYmplY3QscGFzc1N0eWxlT2YsbWFrZVRhZ2dlZDskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiWFwiLCBbJGjNj19hID0+IChYID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRozY9fYSA9PiAoRSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJpc09iamVjdFwiLCBbJGjNj19hID0+IChpc09iamVjdCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaM2PX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjNj19hKV1dXV0sW1wiLi9tYWtlVGFnZ2VkLmpzXCIsIFtbXCJtYWtlVGFnZ2VkXCIsIFskaM2PX2EgPT4gKG1ha2VUYWdnZWQgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtQYXNzYWJsZSwgUHJpbWl0aXZlLCBDb3B5UmVjb3JkLCBDb3B5QXJyYXksIENvcHlUYWdnZWQsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnQGVuZG8vcGFzcy1zdHlsZSdcbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7ZnJvbUVudHJpZXN9PU9iamVjdDtcblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7eyBbS2V5VHlwZSBpbiBrZXlvZiBUXTogVFtLZXlUeXBlXSB9ICYge319IFNpbXBsaWZ5IGZsYXR0ZW4gdGhlXG4gKiAgIHR5cGUgb3V0cHV0IHRvIGltcHJvdmUgdHlwZSBoaW50cyBzaG93biBpbiBlZGl0b3JzXG4gKiAgIGh0dHBzOi8vZ2l0aHViLmNvbS9zaW5kcmVzb3JodXMvdHlwZS1mZXN0L2Jsb2IvbWFpbi9zb3VyY2Uvc2ltcGxpZnkuZC50c1xuICovXG5cbi8qKlxuICogQ3VycmVudGx5IGNvcGllZCBmcm9tIEBhZ29yaWMvaW50ZXJuYWwgdXRpbHMuanMuXG4gKiBUT0RPIFNob3VsZCBtaWdyYXRlIGhlcmUgYW5kIHRoZW4sIGlmIG5lZWRlZCwgcmVleHBvcnRlZCB0aGVyZS5cbiAqXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IENhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBDdXJyZW50bHkgY29waWVkIGZyb20gQGFnb3JpYy9pbnRlcm5hbCB1dGlscy5qcy5cbiAqIFRPRE8gU2hvdWxkIG1pZ3JhdGUgaGVyZSBhbmQgdGhlbiwgaWYgbmVlZGVkLCByZWV4cG9ydGVkIHRoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtLIGluIGtleW9mIFRdOiBUW0tdIGV4dGVuZHMgQ2FsbGFibGUgPyBUW0tdIDogRGVlcGx5QXdhaXRlZDxUW0tdPjtcbiAqIH19IERlZXBseUF3YWl0ZWRPYmplY3RcbiAqL1xuXG4vKipcbiAqIEN1cnJlbnRseSBjb3BpZWQgZnJvbSBAYWdvcmljL2ludGVybmFsIHV0aWxzLmpzLlxuICogVE9ETyBTaG91bGQgbWlncmF0ZSBoZXJlIGFuZCB0aGVuLCBpZiBuZWVkZWQsIHJlZXhwb3J0ZWQgdGhlcmUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgUHJvbWlzZUxpa2U8YW55PlxuICogICAgID8gQXdhaXRlZDxUPlxuICogICAgIDogVCBleHRlbmRzIHt9XG4gKiAgICAgICA/IFNpbXBsaWZ5PERlZXBseUF3YWl0ZWRPYmplY3Q8VD4+XG4gKiAgICAgICA6IEF3YWl0ZWQ8VD59IERlZXBseUF3YWl0ZWRcbiAqL1xuXG4vKipcbiAqIEdpdmVuIGEgUGFzc2FibGUgYHZhbGAgd2hvc2UgcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBtYXkgY29udGFpbiBsZWFmXG4gKiBwcm9taXNlcywgcmV0dXJuIGEgcHJvbWlzZSBmb3IgYSByZXBsYWNlbWVudCBQYXNzYWJsZSxcbiAqIHdoZXJlIHRoYXQgcmVwbGFjZW1lbnQgaXMgKmRlZXBseSBmdWxmaWxsZWQqLCBpLmUuLCBpdHNcbiAqIHBhc3MtYnktY29weSBzdHJ1Y3R1cmUgZG9lcyBub3QgY29udGFpbiBhbnkgcHJvbWlzZXMuXG4gKlxuICogVGhpcyBpcyBhIGRlZXAgZm9ybSBvZiBgUHJvbWlzZS5hbGxgIHNwZWNpYWxpemVkIGZvciBQYXNzYWJsZXMuIEZvciBlYWNoXG4gKiBlbmNvdW50ZXJlZCBwcm9taXNlLCByZXBsYWNlIGl0IHdpdGggdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybSBvZlxuICogaXRzIGZ1bGZpbGxtZW50LlxuICogSWYgYW55IG9mIHRoZSBwcm9taXNlcyByZWplY3QsIHRoZW4gdGhlIHByb21pc2UgZm9yIHRoZSByZXBsYWNlbWVudFxuICogcmVqZWN0cy4gSWYgYW55IG9mIHRoZSBwcm9taXNlcyBuZXZlciBzZXR0bGUsIHRoZW4gdGhlIHByb21pc2UgZm9yXG4gKiB0aGUgcmVwbGFjZW1lbnQgbmV2ZXIgc2V0dGxlcy5cbiAqXG4gKiBJZiB0aGUgcmVwbGFjZW1lbnQgd291bGQgbm90IGJlIFBhc3NhYmxlLCBpLmUuLCBpZiBgdmFsYCBpcyBub3RcbiAqIFBhc3NhYmxlLCBvciBpZiBhbnkgb2YgdGhlIHRyYW5zaXRpdmUgcHJvbWlzZXMgZnVsZmlsbCB0byBzb21ldGhpbmdcbiAqIHRoYXQgaXMgbm90IFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBwcm9taXNlIHJlamVjdHMuXG4gKlxuICogSWYgYHZhbGAgb3IgaXRzIHBhcnRzIGFyZSBub24ta2V5IFBhc3NhYmxlcyBvbmx5ICpiZWNhdXNlKiB0aGV5IGNvbnRhaW5cbiAqIHByb21pc2VzLCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtcyBvZiB2YWwgb3IgaXRzIHBhcnRzIG1heSBiZSBrZXlzLiBUaGlzXG4gKiBpcyBmb3IgdGhlIGhpZ2hlciBcIkBlbmRvL3BhdHRlcm5zXCIgbGV2ZWwgb2YgYWJzdHJhY3Rpb24gdG8gZGV0ZXJtaW5lLFxuICogYmVjYXVzZSBpdCBkZWZpbmVzIHRoZSBgS2V5YCBub3Rpb24gaW4gcXVlc3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Q9UGFzc2FibGVdXG4gKiBAcGFyYW0ge1R9IHZhbFxuICogQHJldHVybnMge1Byb21pc2U8RGVlcGx5QXdhaXRlZDxUPj59XG4gKi9cbmNvbnN0ICAgICAgICBkZWVwbHlGdWxmaWxsZWQ9YXN5bmModmFsKT0+e1xuLyogVE9ETyBGaWd1cmUgb3V0IHdoeSB3ZSBuZWVkIHRoZXNlIGF0LWV4cGVjdC1lcnJvciBkaXJlY3RpdmVzIGJlbG93Ki9cbi8qIGFuZCBmaXggaWYgcG9zc2libGUuKi9cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTI1NyBtYXkgYmUgcmVsZXZhbnQuKi9cblxuaWYoIWlzT2JqZWN0KHZhbCkpe1xucmV0dXJuICgvKiogQHR5cGUge0RlZXBseUF3YWl0ZWQ8VD59ICovdmFsKTtcbiB9XG5pZihpc1Byb21pc2UodmFsKSl7XG5yZXR1cm4gRS53aGVuKHZhbCwobm9ucCk9PmRlZXBseUZ1bGZpbGxlZChub25wKSk7XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbCk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnY29weVJlY29yZCc6e1xuY29uc3QgcmVjPS8qKiBAdHlwZSB7Q29weVJlY29yZH0gKi92YWw7XG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjKTtcbmNvbnN0IHZhbFBzPW5hbWVzLm1hcCgobmFtZSk9PmRlZXBseUZ1bGZpbGxlZChyZWNbbmFtZV0pKTtcbi8qIEB0cy1leHBlY3QtZXJyb3Igbm90IGFzc2lnbmFibGUgdG8gdHlwZSAnRGVlcGx5QXdhaXRlZDxUPicqL1xucmV0dXJuIEUud2hlbihQcm9taXNlLmFsbCh2YWxQcyksKHZhbHMpPT5cbmhhcmRlbihmcm9tRW50cmllcyh2YWxzLm1hcCgoYyxpKT0+W25hbWVzW2ldLGNdKSkpKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5jb25zdCBhcnI9LyoqIEB0eXBlIHtDb3B5QXJyYXl9ICovdmFsO1xuY29uc3QgdmFsUHM9YXJyLm1hcCgocCk9PmRlZXBseUZ1bGZpbGxlZChwKSk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oUHJvbWlzZS5hbGwodmFsUHMpLCh2YWxzKT0+aGFyZGVuKHZhbHMpKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGdkPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi92YWw7XG5jb25zdCB0YWc9Z2V0VGFnKHRnZCk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiBFLndoZW4oZGVlcGx5RnVsZmlsbGVkKHRnZC5wYXlsb2FkKSwocGF5bG9hZCk9PlxubWFrZVRhZ2dlZCh0YWcscGF5bG9hZCkpO1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IHJlbT0vKiogQHR5cGUge1JlbW90YWJsZU9iamVjdH0gKi92YWw7XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5vdCBhc3NpZ25hYmxlIHRvIHR5cGUgJ0RlZXBseUF3YWl0ZWQ8VD4nKi9cbnJldHVybiByZW07XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZXJyPS8qKiBAdHlwZSB7RXJyb3J9ICovdmFsO1xuLyogQHRzLWV4cGVjdC1lcnJvciBub3QgYXNzaWduYWJsZSB0byB0eXBlICdEZWVwbHlBd2FpdGVkPFQ+JyovXG5yZXR1cm4gZXJyO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcHJvbT0vKiogQHR5cGUge1Byb21pc2V9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi92YWw7XG5yZXR1cm4gRS53aGVuKHByb20sKG5vbnApPT5kZWVwbHlGdWxmaWxsZWQobm9ucCkpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgYXNzZXJ0LmZhaWwoWCBgVW5leHBlY3RlZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9YCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9OyRozY9fb25jZS5kZWVwbHlGdWxmaWxsZWQoZGVlcGx5RnVsZmlsbGVkKTtcbmhhcmRlbihkZWVwbHlGdWxmaWxsZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVlcGx5RnVsZmlsbGVkIjpbImRlZXBseUZ1bGZpbGxlZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABREv3gLhsAAC4bAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yIiwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiLCJnZXRFcnJvckNvbnN0cnVjdG9yIiwiaXNFcnJvckxpa2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgcSxhc3NlcnRDaGVja2VyLENYOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiQ1hcIiwgWyRozY9fYSA9PiAoQ1ggPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlSGVscGVyfSBmcm9tICcuL2ludGVybmFsLXR5cGVzLmpzJyAqL1xuLyoqIEBpbXBvcnQge0NoZWNrZXIsIFBhc3NTdHlsZSwgUGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2dldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsaGFzT3duLGVudHJpZXN9PU9iamVjdDtcblxuLyogVE9ETzogTWFpbnRlbmFuY2UgaGF6YXJkOiBDb29yZGluYXRlIHdpdGggdGhlIGxpc3Qgb2YgZXJyb3JzIGluIHRoZSBTRVMqL1xuLyogd2hpbGVsaXN0LiovXG5jb25zdCBlcnJvckNvbnN0cnVjdG9ycz1uZXcgTWFwKFxuLyogQ2FzdCBiZWNhdXNlIG90aGVyd2lzZSBUUyBpcyBjb25mdXNlZCBieSBBZ2dyZWdhdGVFcnJvciovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMjA0MiNkaXNjdXNzaW9uX3IxNDg0OTMzMDI4Ki9cbi8qKiBAdHlwZSB7QXJyYXk8W3N0cmluZywgSU1QT1JUKCdzZXMnKS5HZW5lcmljRXJyb3JDb25zdHJ1Y3Rvcl0+fSAqL1xuW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1cblxuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy81NTAqL1xuLyogVG8gYWNjb21tb2RhdGUgcGxhdGZvcm1zIHByaW9yIHRvIEFnZ3JlZ2F0ZUVycm9yLCB3ZSBjb21tZW50IG91dCB0aGUqL1xuLyogZm9sbG93aW5nIGxpbmUgYW5kIGluc3RlYWQgY29uZGl0aW9uYWxseSBhZGQgaXQgdG8gdGhlIG1hcCBiZWxvdy4qL1xuLyogWydBZ2dyZWdhdGVFcnJvcicsIEFnZ3JlZ2F0ZUVycm9yXSwqL10pO1xuXG5cblxuaWYodHlwZW9mIEFnZ3JlZ2F0ZUVycm9yIT09J3VuZGVmaW5lZCcpe1xuLyogQ29uZGl0aW9uYWwsIHRvIGFjY29tbW9kYXRlIHBsYXRmb3JtcyBwcmlvciB0byBBZ2dyZWdhdGVFcnJvciovXG5lcnJvckNvbnN0cnVjdG9ycy5zZXQoJ0FnZ3JlZ2F0ZUVycm9yJyxBZ2dyZWdhdGVFcnJvcik7XG4gfVxuXG4vKipcbiAqIEJlY2F1c2UgdGhlIGVycm9yIGNvbnN0cnVjdG9yIHJldHVybmVkIGJ5IHRoaXMgZnVuY3Rpb24gbWlnaHQgYmVcbiAqIGBBZ2dyZWdhdGVFcnJvcmAsIHdoaWNoIGhhcyBkaWZmZXJlbnQgY29uc3RydWN0aW9uIHBhcmFtZXRlcnNcbiAqIGZyb20gdGhlIG90aGVyIGVycm9yIGNvbnN0cnVjdG9ycywgZG8gbm90IHVzZSBpdCBkaXJlY3RseSB0byB0cnlcbiAqIHRvIG1ha2UgYW4gZXJyb3IgaW5zdGFuY2UuIFJhdGhlciwgdXNlIGBtYWtlRXJyb3JgIHdoaWNoIGVuY2Fwc3VsYXRlc1xuICogdGhpcyBub24tdW5pZm9ybWl0eS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge0lNUE9SVCgnc2VzJykuR2VuZXJpY0Vycm9yQ29uc3RydWN0b3IgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRFcnJvckNvbnN0cnVjdG9yPShuYW1lKT0+ZXJyb3JDb25zdHJ1Y3RvcnMuZ2V0KG5hbWUpOyRozY9fb25jZS5nZXRFcnJvckNvbnN0cnVjdG9yKGdldEVycm9yQ29uc3RydWN0b3IpO1xuaGFyZGVuKGdldEVycm9yQ29uc3RydWN0b3IpO1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja0Vycm9yTGlrZT0oY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9Pntcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxuISFjaGVjayYmQ1goY2hlY2spIGBFcnJvciBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbiB9O1xuaGFyZGVuKGNoZWNrRXJyb3JMaWtlKTtcbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogVmFsaWRhdGluZyBlcnJvciBvYmplY3RzIGFyZSBwYXNzYWJsZSByYWlzZXMgYSB0ZW5zaW9uIGJldHdlZW4gc2VjdXJpdHlcbiAqIHZzIHByZXNlcnZpbmcgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gRm9yIGVycm9ycywgd2UgbmVlZCB0byByZW1lbWJlclxuICogdGhlIGVycm9yIGl0c2VsZiBleGlzdHMgdG8gaGVscCB1cyBkaWFnbm9zZSBhIGJ1ZyB0aGF0J3MgbGlrZWx5IG1vcmVcbiAqIHByZXNzaW5nIHRoYW4gYSB2YWxpZGl0eSBidWcgaW4gdGhlIGVycm9yIGl0c2VsZi4gVGh1cywgd2hlbmV2ZXIgaXQgaXMgc2FmZVxuICogdG8gZG8gc28sIHdlIHByZWZlciB0byBsZXQgdGhlIGVycm9yLWxpa2UgdGVzdCBzdWNjZWVkIGFuZCB0byBjb3VjaCB0aGVzZVxuICogY29tcGxhaW50cyBhcyBub3RlcyBvbiB0aGUgZXJyb3IuXG4gKlxuICogVG8gcmVzb2x2ZSB0aGlzLCBzdWNoIGEgbWFsZm9ybWVkIGVycm9yIG9iamVjdCB3aWxsIHN0aWxsIHBhc3NcbiAqIGBpc0Vycm9yTGlrZWAgc28gbWFyc2hhbCBjYW4gdXNlIHRoaXMgZm9yIHRvcCBsZXZlbCBlcnJvciB0byByZXBvcnQgZnJvbSxcbiAqIGV2ZW4gaWYgaXQgd291bGQgbm90IGFjdHVhbGx5IHZhbGlkYXRlLlxuICogSW5zdGVhZCwgdGhlIGRpYWdub3N0aWNzIHRoYXQgYGFzc2VydEVycm9yYCB3b3VsZCBoYXZlIHJlcG9ydGVkIGFyZVxuICogYXR0YWNoZWQgYXMgbm90ZXMgdG8gdGhlIG1hbGZvcm1lZCBlcnJvci4gVGh1cywgYSBtYWxmb3JtZWRcbiAqIGVycm9yIGlzIHBhc3NhYmxlIGJ5IGl0c2VsZiwgYnV0IG5vdCBhcyBwYXJ0IG9mIGEgcGFzc2FibGUgc3RydWN0dXJlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzRXJyb3JMaWtlPShjYW5kaWRhdGUpPT5jaGVja0Vycm9yTGlrZShjYW5kaWRhdGUpOyRozY9fb25jZS5pc0Vycm9yTGlrZShpc0Vycm9yTGlrZSk7XG5oYXJkZW4oaXNFcnJvckxpa2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBwcm9wTmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEBwYXJhbSB7KHZhbDogYW55KSA9PiBQYXNzU3R5bGV9IHBhc3NTdHlsZU9mUmVjdXJcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYz0oXG5wcm9wTmFtZSxcbmRlc2MsXG5wYXNzU3R5bGVPZlJlY3VyLFxuY2hlY2s9dW5kZWZpbmVkKT0+XG57XG5pZihkZXNjLmVudW1lcmFibGUpe1xucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yICR7cShcbnByb3BOYW1lKVxuIH0gb3duIHByb3BlcnR5IG11c3Qgbm90IGJlIGVudW1lcmFibGU6ICR7ZGVzY31gKTtcblxuIH1cbmlmKCFoYXNPd24oZGVzYywndmFsdWUnKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGRhdGEgcHJvcGVydHk6ICR7ZGVzY31gKTtcblxuIH1cbmNvbnN0e3ZhbHVlfT1kZXNjO1xuc3dpdGNoKHByb3BOYW1lKXtcbmNhc2UnbWVzc2FnZSc6XG5jYXNlJ3N0YWNrJzp7XG5yZXR1cm4oXG50eXBlb2YgdmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt2YWx1ZX1gKTtcblxuIH1cbmNhc2UnY2F1c2UnOntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5yZXR1cm4gY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IodmFsdWUscGFzc1N0eWxlT2ZSZWN1cixjaGVjayk7XG4gfVxuY2FzZSdlcnJvcnMnOntcbmlmKCFBcnJheS5pc0FycmF5KHZhbHVlKXx8cGFzc1N0eWxlT2ZSZWN1cih2YWx1ZSkhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgUGFzc2FibGUgRXJyb3IgJHtxKFxucHJvcE5hbWUpXG4gfSBvd24gcHJvcGVydHkgbXVzdCBiZSBhIGNvcHlBcnJheTogJHt2YWx1ZX1gKTtcblxuIH1cbnJldHVybiB2YWx1ZS5ldmVyeSgoZXJyKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mUmVjdXIsY2hlY2spKTtcblxuIH1cbmRlZmF1bHQ6e1xuYnJlYWs7XG4gfX1cblxucmV0dXJuKFxuISFjaGVjayYmXG5DWChjaGVjaykgYFBhc3NhYmxlIEVycm9yIGhhcyBleHRyYSB1bnBhc3NlZCBwcm9wZXJ0eSAke3EocHJvcE5hbWUpfWApO1xuXG4gfTskaM2PX29uY2UuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MpO1xuaGFyZGVuKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHsodmFsOiBhbnkpID0+IFBhc3NTdHlsZX0gcGFzc1N0eWxlT2ZSZWN1clxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yPShcbmNhbmRpZGF0ZSxcbnBhc3NTdHlsZU9mUmVjdXIsXG5jaGVjaz11bmRlZmluZWQpPT5cbntcbmlmKCFjaGVja0Vycm9yTGlrZShjYW5kaWRhdGUsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpO1xuY29uc3R7bmFtZX09cHJvdG87XG5jb25zdCBlcnJDb25zdHJ1Y3Rvcj1nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpO1xuaWYoZXJyQ29uc3RydWN0b3I9PT11bmRlZmluZWR8fGVyckNvbnN0cnVjdG9yLnByb3RvdHlwZSE9PXByb3RvKXtcbnJldHVybihcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgUGFzc2FibGUgRXJyb3IgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCk7XG5cbiB9XG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZighKCdtZXNzYWdlJ2luIGRlc2NzKSl7XG5yZXR1cm4oXG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYFBhc3NhYmxlIEVycm9yIG11c3QgaGF2ZSBhbiBvd24gXCJtZXNzYWdlXCIgc3RyaW5nIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTtcblxuIH1cblxucmV0dXJuIGVudHJpZXMoZGVzY3MpLmV2ZXJ5KChbcHJvcE5hbWUsZGVzY10pPT5cbmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yUHJvcGVydHlEZXNjKFxucHJvcE5hbWUsXG5kZXNjLFxucGFzc1N0eWxlT2ZSZWN1cixcbmNoZWNrKSk7XG5cblxuIH07JGjNj19vbmNlLmNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKGNoZWNrUmVjdXJzaXZlbHlQYXNzYWJsZUVycm9yKTtcbmhhcmRlbihjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcik7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+XG5jaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cixhc3NlcnRDaGVja2VyKX0pOyRozY9fb25jZS5FcnJvckhlbHBlcihFcnJvckhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MiXSwiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiOlsiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAu5h1k2cIAABnCAAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9pdGVyLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiLi9tYWtlLWZhci5qcyJdLCJleHBvcnRzIjpbImZpbHRlckl0ZXJhYmxlIiwibWFwSXRlcmFibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgRmFyOyRozY9faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaM2PX2EgPT4gKEZhciA9ICRozY9fYSldXV1dXSk7ICAgXG5cbi8qKlxuICogVGhlIHJlc3VsdCBpdGVyYXRvciBoYXMgYXMgbWFueSBlbGVtZW50cyBhcyB0aGUgYGJhc2VJdGVyYXRvcmAgYW5kXG4gKiBoYXZlIHRoZSBzYW1lIHRlcm1pbmF0aW9uIC0tIHRoZSBzYW1lIGNvbXBsZXRpb24gdmFsdWUgb3IgZmFpbHVyZVxuICogcmVhc29uLiBCdXQgdGhlIG5vbi1maW5hbCB2YWx1ZXMgYXJlIHRoZSBjb3JyZXNwb25kaW5nIG5vbi1maW5hbFxuICogdmFsdWVzIGZyb20gYGJhc2VJdGVyYXRvcmAgYXMgdHJhbnNmb3JtZWQgYnkgYGZ1bmNgLlxuICpcbiAqIEB0ZW1wbGF0ZSBULFVcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IGJhc2VJdGVyYWJsZVxuICogQHBhcmFtIHsodmFsdWU6IFQpID0+IFV9IGZ1bmNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxVPn1cbiAqL1xuY29uc3QgICAgICAgIG1hcEl0ZXJhYmxlPShiYXNlSXRlcmFibGUsZnVuYyk9PlxuLyoqIEB0eXBlIHtJdGVyYWJsZTxVPn0gKi9cbkZhcignbWFwcGVkIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgYmFzZUl0ZXJhdG9yPWJhc2VJdGVyYWJsZVtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gRmFyKCdtYXBwZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmNvbnN0e3ZhbHVlOmJhc2VWYWx1ZSxkb25lfT1iYXNlSXRlcmF0b3IubmV4dCgpO1xuY29uc3QgdmFsdWU9ZG9uZT9iYXNlVmFsdWU6ZnVuYyhiYXNlVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7dmFsdWUsZG9uZX0pO1xuIH19KTtcblxuIH19KTskaM2PX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjNj19vbmNlLmZpbHRlckl0ZXJhYmxlKGZpbHRlckl0ZXJhYmxlKTtcblxuaGFyZGVuKGZpbHRlckl0ZXJhYmxlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1hcEl0ZXJhYmxlIjpbIm1hcEl0ZXJhYmxlIl0sImZpbHRlckl0ZXJhYmxlIjpbImZpbHRlckl0ZXJhYmxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN5jxppcJAAAXCQAACcAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZS1mYXIuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qcyIsIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3JlbW90YWJsZS5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkdFVF9NRVRIT0RfTkFNRVMiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldE1ldGhvZE5hbWVzLHEsRmFpbCxhc3NlcnRDaGVja2VyLFBBU1NfU1RZTEUsYXNzZXJ0SWZhY2UsZ2V0SW50ZXJmYWNlT2YsUmVtb3RhYmxlSGVscGVyOyRozY9faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZC91dGlscy5qc1wiLCBbW1wiZ2V0TWV0aG9kTmFtZXNcIiwgWyRozY9fYSA9PiAoZ2V0TWV0aG9kTmFtZXMgPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJGYWlsXCIsIFskaM2PX2EgPT4gKEZhaWwgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcImFzc2VydElmYWNlXCIsIFskaM2PX2EgPT4gKGFzc2VydElmYWNlID0gJGjNj19hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaM2PX2EgPT4gKGdldEludGVyZmFjZU9mID0gJGjNj19hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge1JlbW90YWJsZUJyYW5kfSBmcm9tICdAZW5kby9ldmVudHVhbC1zZW5kJyAqL1xuLyoqIEBpbXBvcnQge0ludGVyZmFjZVNwZWMsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuY29uc3R7cHJvdG90eXBlOmZ1bmN0aW9uUHJvdG90eXBlfT1GdW5jdGlvbjtcbmNvbnN0e1xuZ2V0UHJvdG90eXBlT2YsXG5zZXRQcm90b3R5cGVPZixcbmNyZWF0ZSxcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09XG5PYmplY3Q7XG5cbi8qKlxuICogTm93IHRoYXQgdGhlIHJlbW90YWJsZVByb3RvIGRvZXMgbm90IHByb3ZpZGUgaXRzIG93biBgdG9TdHJpbmdgIG1ldGhvZCxcbiAqIGVuc3VyZSBpdCBhbHdheXMgaW5oZXJpdHMgZnJvbSBzb21ldGhpbmcuIFRoZSBvcmlnaW5hbCBwcm90b3R5cGUgb2ZcbiAqIGByZW1vdGFibGVgIGlmIHRoZXJlIHdhcyBvbmUsIG9yIGBPYmplY3QucHJvdG90eXBlYCBvdGhlcndpc2UuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IHJlbW90YWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHJldHVybnMge29iamVjdH1cbiAqL1xuY29uc3QgbWFrZVJlbW90YWJsZVByb3RvPShyZW1vdGFibGUsaWZhY2UpPT57XG5sZXQgb2xkUHJvdG89Z2V0UHJvdG90eXBlT2YocmVtb3RhYmxlKTtcbmlmKHR5cGVvZiByZW1vdGFibGU9PT0nb2JqZWN0Jyl7XG5pZihvbGRQcm90bz09PW51bGwpe1xub2xkUHJvdG89b2JqZWN0UHJvdG90eXBlO1xuIH1cbm9sZFByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbkZhaWwgYEZvciBub3csIHJlbW90YWJsZXMgY2Fubm90IGluaGVyaXQgZnJvbSBhbnl0aGluZyB1bnVzdWFsLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNlIGlmKHR5cGVvZiByZW1vdGFibGU9PT0nZnVuY3Rpb24nKXtcbm9sZFByb3RvIT09bnVsbHx8XG5GYWlsIGBPcmlnaW5hbCBmdW5jdGlvbiBtdXN0IG5vdCBpbmhlcml0IGZyb20gbnVsbDogJHtyZW1vdGFibGV9YDtcbm9sZFByb3RvPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuZ2V0UHJvdG90eXBlT2Yob2xkUHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuRmFpbCBgRmFyIGZ1bmN0aW9ucyBtdXN0IG9yaWdpbmFsbHkgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZSwgaW4gJHtyZW1vdGFibGV9YDtcbiB9ZWxzZXtcbkZhaWwgYHVucmVjb2duaXplZCB0eXBlb2YgJHtyZW1vdGFibGV9YDtcbiB9XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9sZFByb3RvLHtcbltQQVNTX1NUWUxFXTp7dmFsdWU6J3JlbW90YWJsZSd9LFxuW1N5bWJvbC50b1N0cmluZ1RhZ106e3ZhbHVlOmlmYWNlfX0pKTtcblxuXG4gfTtcblxuY29uc3QgYXNzZXJ0Q2FuQmVSZW1vdGFibGU9KGNhbmRpZGF0ZSk9PlxuUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENyZWF0ZSBhbmQgcmVnaXN0ZXIgYSBSZW1vdGFibGUuICBBZnRlciB0aGlzLCBnZXRJbnRlcmZhY2VPZihyZW1vdGFibGUpXG4gKiByZXR1cm5zIGlmYWNlLlxuICpcbiAqIC8vIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvODA0XG4gKlxuICogQHRlbXBsYXRlIHt7fX0gVFxuICogQHRlbXBsYXRlIHtJbnRlcmZhY2VTcGVjfSBJXG4gKiBAcGFyYW0ge0l9IFtpZmFjZV0gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHNdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlT2JqZWN0PEk+ICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fX0gcmVtb3RhYmxlLCBtb2RpZmllZCBmb3IgZGVidWdnYWJpbGl0eVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlPShcbi8qIEB0cy1leHBlY3QtZXJyb3IgSSBjb3VsZCBoYXZlIGRpZmZlcmVudCBzdWJ0eXBlIHRoYW4gc3RyaW5nKi9cbmlmYWNlPSdSZW1vdGFibGUnLFxucHJvcHM9dW5kZWZpbmVkLFxucmVtb3RhYmxlPS8qKiBAdHlwZSB7VH0gKi97fSk9Plxue1xuYXNzZXJ0SWZhY2UoaWZhY2UpO1xuYXNzZXJ0KGlmYWNlKTtcbi8qIFRPRE86IFdoZW4gaWZhY2UgaXMgcmljaGVyIHRoYW4ganVzdCBzdHJpbmcsIHdlIG5lZWQgdG8gZ2V0IHRoZSBhbGxlZ2VkTmFtZSovXG4vKiBpbiBhIGRpZmZlcmVudCB3YXkuKi9cbnByb3BzPT09dW5kZWZpbmVkfHxGYWlsIGBSZW1vdGFibGUgcHJvcHMgbm90IHlldCBpbXBsZW1lbnRlZCAke3Byb3BzfWA7XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgdGhhdCB0aGUgdW5tb2RpZmllZCBvYmplY3QgaXMgYWJsZSB0byBiZWNvbWUgYSBSZW1vdGFibGUuKi9cbmFzc2VydENhbkJlUmVtb3RhYmxlKHJlbW90YWJsZSk7XG5cbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBtYXJrZWQuKi9cbiEoUEFTU19TVFlMRSBpbiByZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBtYXJrZWQgYXMgYSAke3EoXG5yZW1vdGFibGVbUEFTU19TVFlMRV0pXG4gfWA7XG4vKiBgaXNGcm96ZW5gIGFsd2F5cyByZXR1cm5zIHRydWUgd2l0aCBhIGZha2UgYGhhcmRlbmAsIGJ1dCB3ZSB3YW50IHRoYXQgY2FzZSovXG4vKiB0byBzdWNjZWVkIGFueXdheS4gRmFraW5nIGBoYXJkZW5gIGlzIG9ubHkgY29ycmVjdG5lc3MgcHJlc2VydmluZyovXG4vKiBpZiB0aGUgY29kZSBpbiBxdWVzdGlvbiBjb250YWlucyBubyBidWdzIHRoYXQgdGhlIHJlYWwgYGhhcmRlbmAgd291bGQqL1xuLyogaGF2ZSBjYXVnaHQuKi9cbi8qIEB0cy1pZ25vcmUgYGlzRmFrZWAgcHVycG9zZWx5IG5vdCBpbiB0aGUgdHlwZSovXG5oYXJkZW4uaXNGYWtlfHxcbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBmcm96ZW4uKi9cbiFpc0Zyb3plbihyZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBmcm96ZW5gO1xuY29uc3QgcmVtb3RhYmxlUHJvdG89bWFrZVJlbW90YWJsZVByb3RvKHJlbW90YWJsZSxpZmFjZSk7XG5cbi8qIFRha2UgYSBzdGF0aWMgY29weSBvZiB0aGUgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBhcyBkYXRhIHByb3BlcnRpZXMuKi9cbi8qIGNvbnN0IHByb3BEZXNjcyA9IGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoeyAuLi5wcm9wcyB9KTsqL1xuY29uc3QgbXV0YXRlSGFyZGVuQW5kQ2hlY2s9KHRhcmdldCk9Pntcbi8qIGRlZmluZVByb3BlcnRpZXModGFyZ2V0LCBwcm9wRGVzY3MpOyovXG5zZXRQcm90b3R5cGVPZih0YXJnZXQscmVtb3RhYmxlUHJvdG8pO1xuaGFyZGVuKHRhcmdldCk7XG5hc3NlcnRDYW5CZVJlbW90YWJsZSh0YXJnZXQpO1xuIH07XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgYSBmcmVzaCByZW1vdGFibGUgdG8gc2VlIGlmIG91ciBydWxlcyBmaXQuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHt9KTtcblxuLyogQWN0dWFsbHkgZmluaXNoIHRoZSBuZXcgcmVtb3RhYmxlLiovXG5tdXRhdGVIYXJkZW5BbmRDaGVjayhyZW1vdGFibGUpO1xuXG4vKiBDT01NSVRURUQhKi9cbi8qIFdlJ3JlIGNvbW1pdHRlZCwgc28ga2VlcCB0aGUgaW50ZXJmYWNlIGZvciBmdXR1cmUgcmVmZXJlbmNlLiovXG5hc3NlcnQoaWZhY2UhPT11bmRlZmluZWQpOy8qIFRvIG1ha2UgVHlwZVNjcmlwdCBoYXBweSovXG5yZXR1cm4gKC8qKiBAdHlwZSB7YW55fSAqL3JlbW90YWJsZSk7XG4gfTskaM2PX29uY2UuUmVtb3RhYmxlKFJlbW90YWJsZSk7XG5oYXJkZW4oUmVtb3RhYmxlKTtcblxuLyoqXG4gKiBUaGUgbmFtZSBvZiB0aGUgYXV0b21hdGljYWxseSBhZGRlZCBkZWZhdWx0IG1ldGEtbWV0aG9kIGZvciBvYnRhaW5pbmcgYVxuICogbGlzdCBvZiBhbGwgbWV0aG9kcyBvZiBhbiBvYmplY3QgZGVjbGFyZWQgd2l0aCBgRmFyYCwgb3IgYW4gb2JqZWN0IHRoYXRcbiAqIGluaGVyaXRzIGZyb20gYW4gb2JqZWN0IGRlY2xhcmVkIHdpdGggYEZhcmAuXG4gKlxuICogTW9kZWxlZCBvbiBgR0VUX0lOVEVSRkFDRV9HVUFSRGAgZnJvbSBgQGVuZG8vZXhvYC5cbiAqXG4gKiBUT0RPIE5hbWUgdG8gYmUgYmlrZXNoZWQuIFBlcmhhcHMgZXZlbiB3aGV0aGVyIGl0IGlzIGFcbiAqIHN0cmluZyBvciBzeW1ib2wgdG8gYmUgYmlrZXNoZWQuIFNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTgwOSNkaXNjdXNzaW9uX3IxMzg4MDUyNDU0XG4gKlxuICogSEFaQVJEOiBCZXdhcmUgdGhhdCBhbiBleG8ncyBpbnRlcmZhY2UgY2FuIGNoYW5nZSBhY3Jvc3MgYW4gdXBncmFkZSxcbiAqIHNvIHJlbW90ZXMgdGhhdCBjYWNoZSBpdCBjYW4gYmVjb21lIHN0YWxlLlxuICovXG5jb25zdCAgICAgICAgR0VUX01FVEhPRF9OQU1FUz0nX19nZXRNZXRob2ROYW1lc19fJztcblxuLyoqXG4gKiBOb3RlIHRoYXQgYGdldE1ldGhvZE5hbWVzTWV0aG9kYCBpcyBhIHRoaXNmdWwgbWV0aG9kISBJdCBtdXN0IGJlIHNvIHRoYXRcbiAqIGl0IHdvcmtzIGFzIGV4cGVjdGVkIHdpdGggZmFyLW9iamVjdCBpbmhlcml0YW5jZS5cbiAqXG4gKiBAcmV0dXJucyB7KHN0cmluZ3xzeW1ib2wpW119XG4gKi8kaM2PX29uY2UuR0VUX01FVEhPRF9OQU1FUyhHRVRfTUVUSE9EX05BTUVTKTtcbmNvbnN0IGdldE1ldGhvZE5hbWVzTWV0aG9kPWhhcmRlbih7XG5bR0VUX01FVEhPRF9OQU1FU10oKXtcbnJldHVybiBnZXRNZXRob2ROYW1lcyh0aGlzKTtcbiB9fSlbXG5HRVRfTUVUSE9EX05BTUVTXTtcblxuY29uc3QgZ2V0TWV0aG9kTmFtZXNEZXNjcmlwdG9yPWhhcmRlbih7XG52YWx1ZTpnZXRNZXRob2ROYW1lc01ldGhvZCxcbmVudW1lcmFibGU6ZmFsc2UsXG5jb25maWd1cmFibGU6ZmFsc2UsXG53cml0YWJsZTpmYWxzZX0pO1xuXG5cbi8qKlxuICogTWFyayBhbiBvYmplY3QgdG8gYmUgZXhwb3NlZCBmb3IgcmVtb3RlIGludGVyYWN0aW9uXG4gKiBhbmQgZ2l2ZSBpdCBhIHN1Z2dlc3RpdmUgaW50ZXJmYWNlIG5hbWUgZm9yIGRlYnVnZ2luZy5cbiAqXG4gKiBBbGwgcHJvcGVydGllcyBvZiB0aGUgb2JqZWN0IGhhdmUgdG8gYmUgbWV0aG9kcywgbm90IGRhdGEuXG4gKlxuICogVGhlIG9iamVjdCBtdXN0IG5vdCBiZSBoYXJkZW5lZCBiZWZvcmUgaXQgaXMgbWFya2VkLlxuICogSXQgd2lsbCBiZSBoYXJkZW5lZCBhZnRlciBtYXJraW5nLlxuICpcbiAqIEZvciBmYXIgb2JqZWN0cyAoYXMgb3Bwb3NlZCB0byBmYXIgZnVuY3Rpb25zKSwgYWxzbyBhZGRzXG4gKiBgX19nZXRNZXRob2ROYW1lc19fYCBtZXRob2QgdGhhdCByZXR1cm5zIGFuIGFycmF5IG9mIGFsbCB0aGUgbWV0aG9kIG5hbWVzLFxuICogaWYgdGhlcmUgaXMgbm90IHlldCBhbnkgbWV0aG9kIG5hbWVkIGBfX2dldE1ldGhvZE5hbWVzX19gLlxuICpcbiAqIEBleGFtcGxlXG4gKiBGYXIoJ0VtcGxveWVlJywgeyBnZXRNYW5hZ2VyIH0pXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZmFyTmFtZSBUaGlzIG5hbWUgd2lsbCBiZSBwcmVwZW5kZWQgd2l0aCBgQWxsZWdlZDogYFxuICogZm9yIG5vdyB0byBmb3JtIHRoZSBgUmVtb3RhYmxlYCBgaWZhY2VgIGFyZ3VtZW50LlxuICogQHBhcmFtIHtUfSBbcmVtb3RhYmxlXSBUaGUgb2JqZWN0IHRvIGJlIG1hcmtlZCBhcyByZW1vdGFibGVcbiAqL1xuY29uc3QgICAgICAgIEZhcj0oZmFyTmFtZSxyZW1vdGFibGU9dW5kZWZpbmVkKT0+e1xuY29uc3Qgcj1yZW1vdGFibGU9PT11bmRlZmluZWQ/LyoqIEB0eXBlIHtUfSAqL3t9OnJlbW90YWJsZTtcbmlmKHR5cGVvZiByPT09J29iamVjdCcmJiEoR0VUX01FVEhPRF9OQU1FUyBpbiByKSl7XG4vKiBUaGlzIHRlc3QgZXhjbHVkZXMgZmFyIGZ1bmN0aW9ucywgc2luY2Ugd2UgY3VycmVudGx5IGNvbnNpZGVyIHRoZW0qL1xuLyogdG8gb25seSBoYXZlIGEgY2FsbC1iZWhhdmlvciwgd2l0aCBubyBjYWxsYWJsZSBtZXRob2RzLiovXG4vKiBCZXdhcmU6IE11dGF0ZXMgdGhlIGlucHV0IGFyZ3VtZW50ISBCdXQgYFJlbW90YWJsZWAqL1xuLyogKiByZXF1aXJlcyB0aGUgb2JqZWN0IHRvIGJlIG11dGFibGUqL1xuLyogKiBkb2VzIGZ1cnRoZXIgbXV0YXRpb25zLCovXG4vKiAqIGhhcmRlbnMgdGhlIG11dGF0ZWQgb2JqZWN0IGJlZm9yZSByZXR1cm5pbmcgaXQuKi9cbi8qIHNvIHRoaXMgbXV0YXRpb24gaXMgbm90IHVucHJlY2VkZW50ZWQuIEJ1dCBpdCBpcyBzdXJwcmlzaW5nISovXG5PYmplY3QuZGVmaW5lUHJvcGVydHkocixHRVRfTUVUSE9EX05BTUVTLGdldE1ldGhvZE5hbWVzRGVzY3JpcHRvcik7XG4gfVxucmV0dXJuIFJlbW90YWJsZSggYEFsbGVnZWQ6ICR7ZmFyTmFtZX1gLHVuZGVmaW5lZCxyKTtcbiB9OyRozY9fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gRlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0ge0Z9IGZ1bmNcbiAqIEByZXR1cm5zIHtGICYgUmVtb3RhYmxlT2JqZWN0ICYgUmVtb3RhYmxlQnJhbmQ8e30sIEY+fVxuICovXG5jb25zdCAgICAgICAgVG9GYXJGdW5jdGlvbj0oZmFyTmFtZSxmdW5jKT0+e1xuaWYoZ2V0SW50ZXJmYWNlT2YoZnVuYykhPT11bmRlZmluZWQpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjaGVja2VkIGNhc3QqL1xucmV0dXJuIGZ1bmM7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBjb3VsZCBiZSBkaWZmZXJlbnQgc3VidHlwZSovXG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRozY9fb25jZS5Ub0ZhckZ1bmN0aW9uKFRvRmFyRnVuY3Rpb24pO1xuaGFyZGVuKFRvRmFyRnVuY3Rpb24pO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUmVtb3RhYmxlIjpbIlJlbW90YWJsZSJdLCJHRVRfTUVUSE9EX05BTUVTIjpbIkdFVF9NRVRIT0RfTkFNRVMiXSwiRmFyIjpbIkZhciJdLCJUb0ZhckZ1bmN0aW9uIjpbIlRvRmFyRnVuY3Rpb24iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGVoiOh4FAAAeBQAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlVGFnZ2VkLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyIsIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3Bhc3NTdHlsZU9mLmpzIl0sImV4cG9ydHMiOlsibWFrZVRhZ2dlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLFBBU1NfU1RZTEUsYXNzZXJ0UGFzc2FibGU7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaM2PX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjNj19hKV1dXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBUXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQXG4gKiBAcGFyYW0ge1R9IHRhZ1xuICogQHBhcmFtIHtQfSBwYXlsb2FkXG4gKiBAcmV0dXJucyB7SU1QT1JUKCcuL3R5cGVzLmpzJykuQ29weVRhZ2dlZDxULFA+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRozY9fb25jZS5tYWtlVGFnZ2VkKG1ha2VUYWdnZWQpO1xuaGFyZGVuKG1ha2VUYWdnZWQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRhZ2dlZCI6WyJtYWtlVGFnZ2VkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJN29GkbHAAAGxwAADAAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiQ1giLCJQQVNTX1NUWUxFIiwiYXNzZXJ0Q2hlY2tlciIsImNhbkJlTWV0aG9kIiwiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCIsImNoZWNrUGFzc1N0eWxlIiwiY2hlY2tUYWdSZWNvcmQiLCJnZXRPd25EYXRhRGVzY3JpcHRvciIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBYLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIlhcIiwgWyRozY9fYSA9PiAoWCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IsXG5nZXRQcm90b3R5cGVPZixcbmhhc093blByb3BlcnR5Om9iamVjdEhhc093blByb3BlcnR5LFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcbmNvbnN0e2FwcGx5fT1SZWZsZWN0O1xuY29uc3R7dG9TdHJpbmdUYWc6dG9TdHJpbmdUYWdTeW1ib2x9PVN5bWJvbDtcblxuY29uc3QgdHlwZWRBcnJheVByb3RvdHlwZT1nZXRQcm90b3R5cGVPZihVaW50OEFycmF5LnByb3RvdHlwZSk7XG5jb25zdCB0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjPWdldE93blByb3BlcnR5RGVzY3JpcHRvcihcbnR5cGVkQXJyYXlQcm90b3R5cGUsXG50b1N0cmluZ1RhZ1N5bWJvbCk7XG5cbmFzc2VydCh0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjKTtcbmNvbnN0IGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZz10eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjLmdldDtcbmFzc2VydCh0eXBlb2YgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPT09J2Z1bmN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBoYXNPd25Qcm9wZXJ0eU9mPShvYmoscHJvcCk9PlxuYXBwbHkob2JqZWN0SGFzT3duUHJvcGVydHksb2JqLFtwcm9wXSk7JGjNj19vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbi8qIFRPRE8gdHJ5IHR5cGluZyB0aGlzOyBgPT4gdmFsIGlzIHt9IHRvbyBuYXJyb3csIGltcGxpZXMgbm8gcHJvcGVydGllcyovXG5jb25zdCAgICAgICAgaXNPYmplY3Q9KHZhbCk9Pk9iamVjdCh2YWwpPT09dmFsOyRozY9fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRozY9fb25jZS5pc1R5cGVkQXJyYXkoaXNUeXBlZEFycmF5KTtcbmhhcmRlbihpc1R5cGVkQXJyYXkpO1xuXG5jb25zdCAgICAgICAgUEFTU19TVFlMRT1TeW1ib2wuZm9yKCdwYXNzU3R5bGUnKTtcblxuLyoqXG4gKiBGb3IgYSBmdW5jdGlvbiB0byBiZSBhIHZhbGlkIG1ldGhvZCwgaXQgbXVzdCBub3QgYmUgcGFzc2FibGUuXG4gKiBPdGhlcndpc2UsIHdlIHJpc2sgY29uZnVzaW5nIHBhc3MtYnktY29weSBkYXRhIGNhcnJ5aW5nXG4gKiBmYXIgZnVuY3Rpb25zIHdpdGggYXR0ZW1wdHMgYXQgZmFyIG9iamVjdHMgd2l0aCBtZXRob2RzLlxuICpcbiAqIFRPRE8gSEFaQVJEIEJlY2F1c2Ugd2UgY2hlY2sgdGhpcyBvbiB0aGUgd2F5IHRvIGhhcmRlbmluZyBhIHJlbW90YWJsZSxcbiAqIHdlIGNhbm5vdCB5ZXQgY2hlY2sgdGhhdCBgZnVuY2AgaXMgaGFyZGVuZWQuIEhvd2V2ZXIsIHdpdGhvdXRcbiAqIGRvaW5nIHNvLCBpdCdzIGluaGVyaXRhbmNlIG1pZ2h0IGNoYW5nZSBhZnRlciB0aGUgYFBBU1NfU1RZTEVgXG4gKiBjaGVjayBiZWxvdy5cbiAqXG4gKiBAcGFyYW0ge2FueX0gZnVuY1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaM2PX29uY2UuUEFTU19TVFlMRShQQVNTX1NUWUxFKTtcbmNvbnN0ICAgICAgICBjYW5CZU1ldGhvZD0oZnVuYyk9PlxudHlwZW9mIGZ1bmM9PT0nZnVuY3Rpb24nJiYhKFBBU1NfU1RZTEUgaW4gZnVuYyk7JGjNj19vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjNj19vbmNlLmFzc2VydENoZWNrZXIoYXNzZXJ0Q2hlY2tlcik7XG5oYXJkZW4oYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogUmV0dXJucyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIGZ1bmN0aW9uIHRvIGZhaWwgdGhlIHByb3ZpZGVkIENoZWNrZXIgd2l0aCBkZXRhaWxzLlxuICogVGhlIG5hbWUgbXVzdCBiZSBzaG9ydCBmb3IgZXJnb25vbWljIGlubGluZSB1c2UgYXMgaW46XG4gKiBgYGBcbiAqIHJldHVybiBjaGVja0NvbmRpdGlvbiguLi4pIHx8ICghIWNoZWNrICYmIENYKGNoZWNrKWAuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY29uc3QgICAgICAgIENYPShjaGVjayk9PntcbmNvbnN0IHJlamVjdD0oVCwuLi5zdWJzKT0+Y2hlY2soZmFsc2UsWChULC4uLnN1YnMpKTtcbnJldHVybiByZWplY3Q7XG4gfTskaM2PX29uY2UuQ1goQ1gpO1xuaGFyZGVuKENYKTtcblxuLyoqXG4gKiBWZXJpZmllcyB0aGUgcHJlc2VuY2UgYW5kIGVudW1lcmFiaWxpdHkgb2YgYW4gb3duIGRhdGEgcHJvcGVydHlcbiAqIGFuZCByZXR1cm5zIGl0cyBkZXNjcmlwdG9yLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BOYW1lXG4gKiBAcGFyYW0ge2Jvb2xlYW59IHNob3VsZEJlRW51bWVyYWJsZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7UHJvcGVydHlEZXNjcmlwdG9yfVxuICovXG5jb25zdCAgICAgICAgZ2V0T3duRGF0YURlc2NyaXB0b3I9KFxuY2FuZGlkYXRlLFxucHJvcE5hbWUsXG5zaG91bGRCZUVudW1lcmFibGUsXG5jaGVjayk9Plxue1xuY29uc3QgZGVzYz0vKiogQHR5cGUge1Byb3BlcnR5RGVzY3JpcHRvcn0gKi9cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcihjYW5kaWRhdGUscHJvcE5hbWUpO1xuXG5yZXR1cm4oZGVzYyE9PXVuZGVmaW5lZHx8XG4hIWNoZWNrJiZDWChjaGVjaykgYCR7cShwcm9wTmFtZSl9IHByb3BlcnR5IGV4cGVjdGVkOiAke2NhbmRpZGF0ZX1gKSYmKFxuaGFzT3duUHJvcGVydHlPZihkZXNjLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gYWNjZXNzb3IgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWApJiYoXG5zaG91bGRCZUVudW1lcmFibGU/XG5kZXNjLmVudW1lcmFibGV8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGAke3EocHJvcE5hbWUpfSBtdXN0IGJlIGFuIGVudW1lcmFibGUgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWA6XG4hZGVzYy5lbnVtZXJhYmxlfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgJHtxKHByb3BOYW1lKX0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCk/XG5kZXNjOlxuLyoqIEB0eXBlIHtQcm9wZXJ0eURlc2NyaXB0b3J9ICovIC8qKiBAdHlwZSB7dW5rbm93bn0gKi91bmRlZmluZWQ7XG4gfTskaM2PX29uY2UuZ2V0T3duRGF0YURlc2NyaXB0b3IoZ2V0T3duRGF0YURlc2NyaXB0b3IpO1xuaGFyZGVuKGdldE93bkRhdGFEZXNjcmlwdG9yKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0lNUE9SVCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IFRcbiAqIEBwYXJhbSB7SU1QT1JUKCcuL3R5cGVzLmpzJykuUGFzc1N0eWxlZDxhbnksIFQ+fSB0YWdSZWNvcmRcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgZ2V0VGFnPSh0YWdSZWNvcmQpPT50YWdSZWNvcmRbU3ltYm9sLnRvU3RyaW5nVGFnXTskaM2PX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmoscGFzc1N0eWxlLGV4cGVjdGVkUGFzc1N0eWxlLGNoZWNrKT0+e1xucmV0dXJuKFxucGFzc1N0eWxlPT09ZXhwZWN0ZWRQYXNzU3R5bGV8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYEV4cGVjdGVkICR7cShleHBlY3RlZFBhc3NTdHlsZSl9LCBub3QgJHtxKHBhc3NTdHlsZSl9OiAke29ian1gKTtcblxuIH07JGjNj19vbmNlLmNoZWNrUGFzc1N0eWxlKGNoZWNrUGFzc1N0eWxlKTtcbmhhcmRlbihjaGVja1Bhc3NTdHlsZSk7XG5cbmNvbnN0IG1ha2VDaGVja1RhZ1JlY29yZD0oY2hlY2tQcm90byk9Pntcbi8qKlxuICogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVkPGFueSwgYW55Pn0gdGFnUmVjb3JkXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gZXhwZWN0ZWRQYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQsZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNPYmplY3QodGFnUmVjb3JkKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkmJihcbmlzRnJvemVuKHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBIHRhZ1JlY29yZCBtdXN0IGJlIGZyb3plbjogJHt0YWdSZWNvcmR9YCkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxuISFjaGVjayYmQ1goY2hlY2spIGBBbiBhcnJheSBjYW5ub3QgYmUgYSB0YWdSZWNvcmQ6ICR7dGFnUmVjb3JkfWApJiZcbmNoZWNrUGFzc1N0eWxlKFxudGFnUmVjb3JkLFxuZ2V0T3duRGF0YURlc2NyaXB0b3IodGFnUmVjb3JkLFBBU1NfU1RZTEUsZmFsc2UsY2hlY2spLnZhbHVlLFxuZXhwZWN0ZWRQYXNzU3R5bGUsXG5jaGVjaykmJihcblxudHlwZW9mIGdldE93bkRhdGFEZXNjcmlwdG9yKHRhZ1JlY29yZCxTeW1ib2wudG9TdHJpbmdUYWcsZmFsc2UsY2hlY2spLlxudmFsdWU9PT0nc3RyaW5nJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkmJlxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaM2PX29uY2UuY2hlY2tUYWdSZWNvcmQoY2hlY2tUYWdSZWNvcmQpO1xuXG5oYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuXG5jb25zdCAgICAgICAgY2hlY2tGdW5jdGlvblRhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbnByb3RvIT09bnVsbCYmZ2V0UHJvdG90eXBlT2YocHJvdG8pPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxuISFjaGVjayYmXG5jaGVjayhcbmZhbHNlLFxuWCBgRm9yIGZ1bmN0aW9ucywgYSB0YWdSZWNvcmQgbXVzdCBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlOiAke3ZhbH1gKSk7JGjNj19vbmNlLmNoZWNrRnVuY3Rpb25UYWdSZWNvcmQoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG5cblxuaGFyZGVuKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJDWCI6WyJDWCJdLCJnZXRPd25EYXRhRGVzY3JpcHRvciI6WyJnZXRPd25EYXRhRGVzY3JpcHRvciJdLCJnZXRUYWciOlsiZ2V0VGFnIl0sImNoZWNrUGFzc1N0eWxlIjpbImNoZWNrUGFzc1N0eWxlIl0sImNoZWNrVGFnUmVjb3JkIjpbImNoZWNrVGFnUmVjb3JkIl0sImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiOlsiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgRq/OeDYAAHg2AAAqAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZU9mLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vY29weUFycmF5LmpzIiwiLi9jb3B5UmVjb3JkLmpzIiwiLi90YWdnZWQuanMiLCIuL2Vycm9yLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3N5bWJvbC5qcyIsIi4vc2FmZS1wcm9taXNlLmpzIiwiLi9zdHJpbmcuanMiXSwiZXhwb3J0cyI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCIsImFzc2VydFBhc3NhYmxlIiwiaXNQYXNzYWJsZSIsInBhc3NTdHlsZU9mIiwidG9QYXNzYWJsZUVycm9yIiwidG9UaHJvd2FibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgaXNQcm9taXNlLFgsRmFpbCxxLGFubm90YXRlRXJyb3IsbWFrZUVycm9yLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvclByb3BlcnR5RGVzYyxjaGVja1JlY3Vyc2l2ZWx5UGFzc2FibGVFcnJvcixnZXRFcnJvckNvbnN0cnVjdG9yLGlzRXJyb3JMaWtlLFJlbW90YWJsZUhlbHBlcixhc3NlcnRQYXNzYWJsZVN5bWJvbCxhc3NlcnRTYWZlUHJvbWlzZSxhc3NlcnRQYXNzYWJsZVN0cmluZzskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRozY9fYSA9PiAoaXNQcm9taXNlID0gJGjNj19hKV1dXV0sW1wiQGVuZG8vZXJyb3JzXCIsIFtbXCJYXCIsIFskaM2PX2EgPT4gKFggPSAkaM2PX2EpXV0sW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dLFtcInFcIiwgWyRozY9fYSA9PiAocSA9ICRozY9fYSldXSxbXCJhbm5vdGF0ZUVycm9yXCIsIFskaM2PX2EgPT4gKGFubm90YXRlRXJyb3IgPSAkaM2PX2EpXV0sW1wibWFrZUVycm9yXCIsIFskaM2PX2EgPT4gKG1ha2VFcnJvciA9ICRozY9fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaM2PX2EgPT4gKGlzT2JqZWN0ID0gJGjNj19hKV1dLFtcImlzVHlwZWRBcnJheVwiLCBbJGjNj19hID0+IChpc1R5cGVkQXJyYXkgPSAkaM2PX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjNj19hID0+IChQQVNTX1NUWUxFID0gJGjNj19hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjNj19hID0+IChDb3B5QXJyYXlIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL2NvcHlSZWNvcmQuanNcIiwgW1tcIkNvcHlSZWNvcmRIZWxwZXJcIiwgWyRozY9fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRozY9fYSldXV1dLFtcIi4vdGFnZ2VkLmpzXCIsIFtbXCJUYWdnZWRIZWxwZXJcIiwgWyRozY9fYSA9PiAoVGFnZ2VkSGVscGVyID0gJGjNj19hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRozY9fYSA9PiAoRXJyb3JIZWxwZXIgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2NcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MgPSAkaM2PX2EpXV0sW1wiY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JcIiwgWyRozY9fYSA9PiAoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IgPSAkaM2PX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjNj19hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjNj19hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaM2PX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjNj19hKV1dXV0sW1wiLi9yZW1vdGFibGUuanNcIiwgW1tcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjNj19hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaM2PX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTeW1ib2wgPSAkaM2PX2EpXV1dXSxbXCIuL3NhZmUtcHJvbWlzZS5qc1wiLCBbW1wiYXNzZXJ0U2FmZVByb21pc2VcIiwgWyRozY9fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaM2PX2EpXV1dXSxbXCIuL3N0cmluZy5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTdHJpbmdcIiwgWyRozY9fYSA9PiAoYXNzZXJ0UGFzc2FibGVTdHJpbmcgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGVIZWxwZXJ9IGZyb20gJy4vaW50ZXJuYWwtdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7Q29weUFycmF5LCBDb3B5UmVjb3JkLCBDb3B5VGFnZ2VkLCBQYXNzYWJsZX0gZnJvbSAnLi90eXBlcy5qcycgKi9cbi8qKiBAaW1wb3J0IHtQYXNzU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UGFzc1N0eWxlT2Z9IGZyb20gJy4vdHlwZXMuanMnICovXG4vKiogQGltcG9ydCB7UHJpbWl0aXZlU3R5bGV9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbi8qKiBAdHlwZWRlZiB7RXhjbHVkZTxQYXNzU3R5bGUsIFByaW1pdGl2ZVN0eWxlIHwgXCJwcm9taXNlXCI+fSBIZWxwZXJQYXNzU3R5bGUgKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzRnJvemVuLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsdmFsdWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVyc1xuICogQHJldHVybnMge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIFBhc3NTdHlsZUhlbHBlcj4gfVxuICovXG5cbmNvbnN0IG1ha2VIZWxwZXJUYWJsZT0ocGFzc1N0eWxlSGVscGVycyk9Pntcbi8qKiBAdHlwZSB7UmVjb3JkPEhlbHBlclBhc3NTdHlsZSwgYW55PiAmIHtfX3Byb3RvX186IG51bGx9fSAqL1xuY29uc3QgSGVscGVyVGFibGU9e1xuX19wcm90b19fOm51bGwsXG5jb3B5QXJyYXk6dW5kZWZpbmVkLFxuY29weVJlY29yZDp1bmRlZmluZWQsXG50YWdnZWQ6dW5kZWZpbmVkLFxuZXJyb3I6dW5kZWZpbmVkLFxucmVtb3RhYmxlOnVuZGVmaW5lZH07XG5cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5jb25zdHtzdHlsZU5hbWV9PWhlbHBlcjtcbnN0eWxlTmFtZSBpbiBIZWxwZXJUYWJsZXx8RmFpbCBgVW5yZWNvZ25pemVkIGhlbHBlcjogJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09PT11bmRlZmluZWR8fFxuRmFpbCBgY29uZmxpY3RpbmcgaGVscGVycyBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09aGVscGVyO1xuIH1cbmZvcihjb25zdCBzdHlsZU5hbWUgb2Ygb3duS2V5cyhIZWxwZXJUYWJsZSkpe1xuSGVscGVyVGFibGVbc3R5bGVOYW1lXSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBtaXNzaW5nIGhlbHBlciBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbiB9XG5cbnJldHVybiBoYXJkZW4oSGVscGVyVGFibGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVycyBUaGUgcGFzc1N0eWxlSGVscGVycyB0byByZWdpc3RlcixcbiAqIGluIHByaW9yaXR5IG9yZGVyLlxuICogTk9URSBUaGVzZSBtdXN0IGFsbCBiZSBcInRydXN0ZWRcIixcbiAqIGNvbXBsZXRlLCBhbmQgbm9uLWNvbGxpZGluZy4gYG1ha2VQYXNzU3R5bGVPZmAgbWF5ICphc3N1bWUqIHRoYXQgZWFjaCBoZWxwZXJcbiAqIGRvZXMgd2hhdCBpdCBpcyBzdXBwb3NlZCB0byBkby4gYG1ha2VQYXNzU3R5bGVPZmAgaXMgbm90IHRyeWluZyB0byBkZWZlbmRcbiAqIGl0c2VsZiBhZ2FpbnN0IG1hbGljaW91cyBoZWxwZXJzLCB0aG91Z2ggaXQgZG9lcyBkZWZlbmQgYWdhaW5zdCBzb21lXG4gKiBhY2NpZGVudHMuXG4gKiBAcmV0dXJucyB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IG1ha2VQYXNzU3R5bGVPZj0ocGFzc1N0eWxlSGVscGVycyk9PntcbmNvbnN0IEhlbHBlclRhYmxlPW1ha2VIZWxwZXJUYWJsZShwYXNzU3R5bGVIZWxwZXJzKTtcbmNvbnN0IHJlbW90YWJsZUhlbHBlcj1IZWxwZXJUYWJsZS5yZW1vdGFibGU7XG5cbi8qKlxuICogUHVyZWx5IGZvciBwZXJmb3JtYW5jZS4gSG93ZXZlciBpdCBpcyBtdXRhYmxlIHN0YXRpYyBzdGF0ZSwgYW5kXG4gKiBpdCBkb2VzIGhhdmUgc29tZSBvYnNlcnZhYmlsaXR5IG9uIHByb3hpZXMuIFRPRE8gbmVlZCB0byBhc3Nlc3NcbiAqIHdoZXRoZXIgdGhpcyBjcmVhdGVzIGEgc3RhdGljIGNvbW11bmljYXRpb25zIGNoYW5uZWwuXG4gKlxuICogcGFzc1N0eWxlT2YgZG9lcyBhIGZ1bGwgcmVjdXJzaXZlIHdhbGsgb2YgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBpbiBvcmRlciB0byB2YWxpZGF0ZSB0aGF0IHRoZXkgYXJlIGFjeWNsaWMuIEluIGFkZGl0aW9uXG4gKiBpdCBpcyB1c2VkIGJ5IG90aGVyIGFsZ29yaXRobXMgdG8gcmVjdXJzaXZlbHkgd2FsayB0aGVzZSBwYXNzLWJ5LWNvcHlcbiAqIHN0cnVjdHVyZXMsIHNvIHdpdGhvdXQgdGhpcyBjYWNoZSwgdGhlc2UgYWxnb3JpdGhtcyBjb3VsZCBiZVxuICogTyhOKioyKSBvciB3b3JzZS5cbiAqXG4gKiBAdHlwZSB7V2Vha01hcDxXZWFrS2V5LCBQYXNzU3R5bGU+fVxuICovXG5jb25zdCBwYXNzU3R5bGVNZW1vPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZU9mfVxuICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgcGFzc1N0eWxlT2Y9KHBhc3NhYmxlKT0+e1xuLyogRXZlbiB3aGVuIGEgV2Vha1NldCBpcyBjb3JyZWN0LCB3aGVuIHRoZSBzZXQgaGFzIGEgc2hvcnRlciBsaWZldGltZSovXG4vKiB0aGFuIGl0cyBrZXlzLCB3ZSBwcmVmZXIgYSBTZXQgZHVlIHRvIGV4cGVjdGVkIGltcGxlbWVudGF0aW9uKi9cbi8qIHRyYWRlb2Zmcy4qL1xuY29uc3QgaW5Qcm9ncmVzcz1uZXcgU2V0KCk7XG5cbmNvbnN0IHBhc3NTdHlsZU9mUmVjdXI9KGlubmVyKT0+e1xuY29uc3QgaW5uZXJJc09iamVjdD1pc09iamVjdChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbmNvbnN0IGlubmVyU3R5bGU9cGFzc1N0eWxlTWVtby5nZXQoaW5uZXIpO1xuaWYoaW5uZXJTdHlsZSl7XG5yZXR1cm4gaW5uZXJTdHlsZTtcbiB9XG4haW5Qcm9ncmVzcy5oYXMoaW5uZXIpfHxcbkZhaWwgYFBhc3MtYnktY29weSBkYXRhIGNhbm5vdCBiZSBjeWNsaWMgJHtpbm5lcn1gO1xuaW5Qcm9ncmVzcy5hZGQoaW5uZXIpO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2ZJbnRlcm5hbChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbnBhc3NTdHlsZU1lbW8uc2V0KGlubmVyLHBhc3NTdHlsZSk7XG5pblByb2dyZXNzLmRlbGV0ZShpbm5lcik7XG4gfVxucmV0dXJuIHBhc3NTdHlsZTtcbiB9O1xuXG5jb25zdCBwYXNzU3R5bGVPZkludGVybmFsPShpbm5lcik9PntcbmNvbnN0IHR5cGVzdHI9dHlwZW9mIGlubmVyO1xuc3dpdGNoKHR5cGVzdHIpe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdib29sZWFuJzpcbmNhc2UnbnVtYmVyJzpcbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gdHlwZXN0cjtcbiB9XG5jYXNlJ3N0cmluZyc6e1xuYXNzZXJ0UGFzc2FibGVTdHJpbmcoaW5uZXIpO1xucmV0dXJuJ3N0cmluZyc7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKGlubmVyKTtcbnJldHVybidzeW1ib2wnO1xuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihpbm5lcj09PW51bGwpe1xucmV0dXJuJ251bGwnO1xuIH1cbmlmKCFpc0Zyb3plbihpbm5lcikpe1xuYXNzZXJ0LmZhaWwoXG4vKiBUeXBlZEFycmF5cyBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgaW4gaGFyZGVuKCkqL1xuLyogYW5kIGEgY29ycmVzcG9uZGluZyBzcGVjaWFsIGVycm9yIG1lc3NhZ2UgaGVyZS4qL1xuaXNUeXBlZEFycmF5KGlubmVyKT9cblggYENhbm5vdCBwYXNzIG11dGFibGUgdHlwZWQgYXJyYXlzIGxpa2UgJHtpbm5lcn0uYDpcblggYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgKTtcblxuIH1cbmlmKGlzUHJvbWlzZShpbm5lcikpe1xuYXNzZXJ0U2FmZVByb21pc2UoaW5uZXIpO1xucmV0dXJuJ3Byb21pc2UnO1xuIH1cbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xuY29uc3QgcGFzc1N0eWxlVGFnPWlubmVyW1BBU1NfU1RZTEVdO1xuaWYocGFzc1N0eWxlVGFnIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YocGFzc1N0eWxlVGFnLCdzdHJpbmcnKTtcbmNvbnN0IGhlbHBlcj1IZWxwZXJUYWJsZVtwYXNzU3R5bGVUYWddO1xuaGVscGVyIT09dW5kZWZpbmVkfHxcbkZhaWwgYFVucmVjb2duaXplZCBQYXNzU3R5bGU6ICR7cShwYXNzU3R5bGVUYWcpfWA7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc1N0eWxlfSAqL3Bhc3NTdHlsZVRhZyk7XG4gfVxuZm9yKGNvbnN0IGhlbHBlciBvZiBwYXNzU3R5bGVIZWxwZXJzKXtcbmlmKGhlbHBlci5jYW5CZVZhbGlkKGlubmVyKSl7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gaGVscGVyLnN0eWxlTmFtZTtcbiB9XG4gfVxucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuY2FzZSdmdW5jdGlvbic6e1xuaXNGcm96ZW4oaW5uZXIpfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgO1xudHlwZW9mIGlubmVyLnRoZW4hPT0nZnVuY3Rpb24nfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1wcm9taXNlIHRoZW5hYmxlc2A7XG5yZW1vdGFibGVIZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4ncmVtb3RhYmxlJztcbiB9XG5kZWZhdWx0OntcbnRocm93IGFzc2VydC5mYWlsKFggYFVucmVjb2duaXplZCB0eXBlb2YgJHtxKHR5cGVzdHIpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTtcblxucmV0dXJuIHBhc3NTdHlsZU9mUmVjdXIocGFzc2FibGUpO1xuIH07XG5yZXR1cm4gaGFyZGVuKHBhc3NTdHlsZU9mKTtcbiB9O1xuXG5jb25zdCAgICAgICAgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2w9U3ltYm9sLmZvcignQGVuZG8gcGFzc1N0eWxlT2YnKTtcblxuLyoqXG4gKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgUGFzc1N0eWxlT2ZFbmRvd21lbnRTeW1ib2wgcHJvcGVydHkgb24gdGhlIGdsb2JhbCxcbiAqIHRoZW4gcHJlc3VtYWJseSBpdCB3YXMgZW5kb3dlZCBmb3IgdXMgYnkgbGl2ZXNsb3RzIHdpdGggYSBgcGFzc1N0eWxlT2ZgXG4gKiBmdW5jdGlvbiwgc28gd2Ugc2hvdWxkIHVzZSBhbmQgZXhwb3J0IHRoYXQgb25lIGluc3RlYWQuXG4gKiBPdGhlciBzb2Z0d2FyZSBtYXkgaGF2ZSBsZWZ0IGl0IGZvciB1cyBoZXJlLFxuICogYnV0IGl0IHdvdWxkIHJlcXVpcmUgd3JpdGUgYWNjZXNzIHRvIG91ciBnbG9iYWwsIG9yIHRoZSBhYmlsaXR5IHRvXG4gKiBwcm92aWRlIGVuZG93bWVudHMgdG8gb3VyIGdsb2JhbCwgYm90aCBvZiB3aGljaCBzZWVtcyBhZGVxdWF0ZSBhcyBhIHRlc3Qgb2ZcbiAqIHdoZXRoZXIgaXQgaXMgYXV0aG9yaXplZCB0byBzZXJ2ZSB0aGUgc2FtZSByb2xlIGFzIGxpdmVzbG90cy5cbiAqXG4gKiBOT1RFIEhBWkFSRDogVGhpcyB1c2UgYnkgbGl2ZXNsb3RzIGRvZXMgcmVseSBvbiBgcGFzc1N0eWxlT2ZgIGJlaW5nXG4gKiBkZXRlcm1pbmlzdGljLiBJZiBpdCBpcyBub3QsIHRoZW4gaW4gYSBsaXZlc2xvdC1saWtlIHZpcnR1YWxpemVkXG4gKiBlbnZpcm9ubWVudCwgaXQgY2FuIGJlIHVzZWQgdG8gZGV0ZWN0IEdDLlxuICpcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqLyRozY9fb25jZS5QYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbChQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCk7XG5jb25zdCAgICAgICAgcGFzc1N0eWxlT2Y9XG5nbG9iYWxUaGlzJiZnbG9iYWxUaGlzW1Bhc3NTdHlsZU9mRW5kb3dtZW50U3ltYm9sXXx8XG5tYWtlUGFzc1N0eWxlT2YoW1xuQ29weUFycmF5SGVscGVyLFxuQ29weVJlY29yZEhlbHBlcixcblRhZ2dlZEhlbHBlcixcbkVycm9ySGVscGVyLFxuUmVtb3RhYmxlSGVscGVyXSk7JGjNj19vbmNlLnBhc3NTdHlsZU9mKHBhc3NTdHlsZU9mKTtcblxuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGU9KHZhbCk9PntcbnBhc3NTdHlsZU9mKHZhbCk7LyogdGhyb3dzIGlmIHZhbCBpcyBub3QgYSBwYXNzYWJsZSovXG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcblxuLyoqXG4gKiBJcyBgc3BlY2ltZW5gIFBhc3NhYmxlPyBUaGlzIHJldHVybnMgdHJ1ZSBpZmYgYHBhc3NTdHlsZU9mKHNwZWNpbWVuKWBcbiAqIHJldHVybnMgYSBzdHJpbmcuIFRoaXMgcmV0dXJucyBgZmFsc2VgIGlmZiBgcGFzc1N0eWxlT2Yoc3BlY2ltZW4pYCB0aHJvd3MuXG4gKiBVbmRlciBubyBub3JtYWwgY2lyY3Vtc3RhbmNlIHNob3VsZCBgaXNQYXNzYWJsZShzcGVjaW1lbilgIHRocm93LlxuICpcbiAqIFRPRE8gRGVwcmVjYXRlIGFuZCB1bHRpbWF0ZWx5IGRlbGV0ZSBAYWdvcmljL2Jhc2Utem9uZSdzIGBpc1Bhc3NhYmxlJyBpblxuICogZmF2b3Igb2YgdGhpcyBvbmUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8yMDk2XG4gKlxuICogVE9ETyBpbXBsZW1lbnQgYW4gaXNQYXNzYWJsZSB0aGF0IGRvZXMgbm90IHJlbHkgb24gdHJ5L2NhdGNoLlxuICogVGhpcyBpbXBsZW1lbnRhdGlvbiBpcyBqdXN0IGEgc3RhbmRpbiB1bnRpbCB0aGVuLlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMjA5NlxuICpcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHJldHVybnMge3NwZWNpbWVuIGlzIFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgaXNQYXNzYWJsZT0oc3BlY2ltZW4pPT57XG50cnl7XG4vKiBJbiBmYWN0LCBpdCBuZXZlciByZXR1cm5zIHVuZGVmaW5lZC4gSXQgZWl0aGVyIHJldHVybnMgYSovXG4vKiBzdHJpbmcgb3IgdGhyb3dzLiovXG5yZXR1cm4gcGFzc1N0eWxlT2Yoc3BlY2ltZW4pIT09dW5kZWZpbmVkO1xuIH1jYXRjaChfKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfTskaM2PX29uY2UuaXNQYXNzYWJsZShpc1Bhc3NhYmxlKTtcbmhhcmRlbihpc1Bhc3NhYmxlKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtQcm9wZXJ0eURlc2NyaXB0b3J9IGRlc2NcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc1Bhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2M9KG5hbWUsZGVzYyk9PlxuY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3JQcm9wZXJ0eURlc2MobmFtZSxkZXNjLHBhc3NTdHlsZU9mKTtcblxuLyoqXG4gKiBBZnRlciBoYXJkZW5pbmcsIGlmIGBlcnJgIGlzIGEgcGFzc2FibGUgZXJyb3IsIHJldHVybiBpdC5cbiAqXG4gKiBPdGhlcndpc2UsIHJldHVybiBhIG5ldyBwYXNzYWJsZSBlcnJvciB0aGF0IHByb3BhZ2F0ZXMgdGhlIGRpYWdub3N0aWNcbiAqIGluZm8gb2YgdGhlIG9yaWdpbmFsLCBhbmQgaXMgbGlua2VkIHRvIHRoZSBvcmlnaW5hbCBhcyBhIG5vdGUuXG4gKlxuICogVE9ETyBBZG9wdCBhIG1vcmUgZmxleGlibGUgbm90aW9uIG9mIHBhc3NhYmxlIGVycm9yLCBpbiB3aGljaFxuICogYSBwYXNzYWJsZSBlcnJvciBjYW4gY29udGFpbiBvdGhlciBvd24gZGF0YSBwcm9wZXJ0aWVzIHdpdGhcbiAqIHRocm93YWJsZSB2YWx1ZXMuXG4gKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0ICAgICAgICB0b1Bhc3NhYmxlRXJyb3I9KGVycik9PntcbmhhcmRlbihlcnIpO1xuaWYoY2hlY2tSZWN1cnNpdmVseVBhc3NhYmxlRXJyb3IoZXJyLHBhc3NTdHlsZU9mKSl7XG5yZXR1cm4gZXJyO1xuIH1cbmNvbnN0e25hbWUsbWVzc2FnZX09ZXJyO1xuY29uc3R7Y2F1c2U6Y2F1c2VEZXNjLGVycm9yczplcnJvcnNEZXNjfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoZXJyKTtcbmxldCBjYXVzZTtcbmxldCBlcnJvcnM7XG5pZihjYXVzZURlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnY2F1c2UnLGNhdXNlRGVzYykpe1xuY2F1c2U9Y2F1c2VEZXNjLnZhbHVlO1xuIH1cbmlmKGVycm9yc0Rlc2MmJmlzUGFzc2FibGVFcnJvclByb3BlcnR5RGVzYygnZXJyb3JzJyxlcnJvcnNEZXNjKSl7XG5lcnJvcnM9ZXJyb3JzRGVzYy52YWx1ZTtcbiB9XG5cbmNvbnN0IGVyckNvbnN0cnVjdG9yPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9bWFrZUVycm9yKCBgJHttZXNzYWdlfWAsZXJyQ29uc3RydWN0b3Ise1xuLyogQHRzLWlnbm9yZSBBc3N1bWluZyBjYXVzZSBpcyBFcnJvciB8IHVuZGVmaW5lZCovXG5jYXVzZSxcbmVycm9yc30pO1xuXG4vKiBTdGlsbCBuZWVkZWQsIGJlY2F1c2UgYG1ha2VFcnJvcmAgb25seSBkb2VzIGEgc2hhbGxvdyBmcmVlemUuKi9cbmhhcmRlbihuZXdFcnJvcik7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hbm5vdGF0ZUVycm9yKG5ld0Vycm9yLFggYGNvcGllZCBmcm9tIGVycm9yICR7ZXJyfWApO1xucGFzc1N0eWxlT2YobmV3RXJyb3IpPT09J2Vycm9yJ3x8XG5GYWlsIGBFeHBlY3RlZCAke25ld0Vycm9yfSB0byBiZSBhIHBhc3NhYmxlIGVycm9yYDtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRozY9fb25jZS50b1Bhc3NhYmxlRXJyb3IodG9QYXNzYWJsZUVycm9yKTtcbmhhcmRlbih0b1Bhc3NhYmxlRXJyb3IpO1xuXG4vKipcbiAqIEFmdGVyIGhhcmRlbmluZywgaWYgYHNwZWNpbWVuYCBpcyB0aHJvd2FibGUsIHJldHVybiBpdC5cbiAqIEEgc3BlY2ltZW4gaXMgdGhyb3dhYmxlIGlmZiBpdCBpcyBQYXNzYWJsZSBhbmQgY29udGFpbnMgbm8gUGFzc2FibGVDYXBzLFxuICogaS5lLiwgbm8gUmVtb3RhYmxlcyBvciBQcm9taXNlcy5cbiAqIElPVywgaWYgaXQgY29udGFpbnMgb25seSBjb3B5LWRhdGEgYW5kIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBPdGhlcndpc2UsIGlmIGBzcGVjaW1lbmAgaXMgKmFsbW9zdCogdGhyb3dhYmxlLCBmb3IgZXhhbXBsZSwgaXQgaXNcbiAqIGFuIGVycm9yIHRoYXQgY2FuIGJlIG1hZGUgdGhyb3dhYmxlIGJ5IGB0b1Bhc3NhYmxlRXJyb3JgLCB0aGVuXG4gKiByZXR1cm4gYHNwZWNpbWVuYCBjb252ZXJ0ZWQgdG8gYSB0aHJvd2FibGUuXG4gKlxuICogT3RoZXJ3aXNlLCB0aHJvdyBhIGRpYWdub3N0aWMgaW5kaWNhdGluZyBhIGZhaWx1cmUgdG8gY29lcmNlLlxuICpcbiAqIFRoaXMgaXMgaW4gc3VwcG9ydCBvZiB0aGUgZXhvIGJvdW5kYXJ5IHRocm93aW5nIG9ubHkgdGhyb3dhYmxlcywgdG8gZWFzZVxuICogc2VjdXJpdHkgcmV2aWV3LlxuICpcbiAqIFRPRE8gQWRvcHQgYSBtb3JlIGZsZXhpdGJsZSBub3Rpb24gb2YgdGhyb3dhYmxlLCBpbiB3aGljaFxuICogZGF0YSBjb250YWluZXJzIGNvbnRhaW5pbmcgbm9uLXBhc3NhYmxlIGVycm9ycyBjYW4gdGhlbXNlbHZlcyBiZSBjb2VyY2VkXG4gKiB0byB0aHJvd2FibGUgYnkgY29lcmNpbmcgdG8gYSBzaW1pbGFyIGNvbnRhaW5lcnMgY29udGFpbmluZ1xuICogdGhlIHJlc3VsdHMgb2YgY29lcmNpbmcgdGhvc2UgZXJyb3JzIHRvIHBhc3NhYmxlIGVycm9ycy5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHNwZWNpbWVuXG4gKiBAcmV0dXJucyB7UGFzc2FibGU8bmV2ZXIsIEVycm9yPn1cbiAqL1xuY29uc3QgICAgICAgIHRvVGhyb3dhYmxlPShzcGVjaW1lbik9PntcbmhhcmRlbihzcGVjaW1lbik7XG5pZihpc0Vycm9yTGlrZShzcGVjaW1lbikpe1xucmV0dXJuIHRvUGFzc2FibGVFcnJvcigvKiogQHR5cGUge0Vycm9yfSAqL3NwZWNpbWVuKTtcbiB9XG4vKiBOb3RlIHRoYXQgdGhpcyBzdGVwIHdpbGwgZmFpbCBpZiBgc3BlY2ltZW5gIHdvdWxkIGJlIGEgcGFzc2FibGUgY29udGFpbmVyKi9cbi8qIGV4Y2VwdCB0aGF0IGl0IGNvbnRhaW5zIG5vbi1wYXNzYWJsZSBlcnJvcnMgdGhhdCBjb3VsZCBiZSBjb252ZXJ0ZWQuKi9cbi8qIFRoaXMgd2lsbCBuZWVkIHRvIGJlIGZpeGVkIHRvIGRvIHRoZSBUT0RPIGFib3ZlLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2Yoc3BlY2ltZW4pO1xuaWYoaXNPYmplY3Qoc3BlY2ltZW4pKXtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5QXJyYXknOntcbmNvbnN0IGVsZW1lbnRzPS8qKiBAdHlwZSB7Q29weUFycmF5fSAqL3NwZWNpbWVuO1xuZm9yKGNvbnN0IGVsZW1lbnQgb2YgZWxlbWVudHMpe1xuZWxlbWVudD09PXRvVGhyb3dhYmxlKGVsZW1lbnQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke2VsZW1lbnR9YDtcbiB9XG5icmVhaztcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmNvbnN0IHJlYz0vKiogQHR5cGUge0NvcHlSZWNvcmR9ICovc3BlY2ltZW47XG5mb3IoY29uc3QgdmFsIG9mIHZhbHVlcyhyZWMpKXtcbnZhbD09PXRvVGhyb3dhYmxlKHZhbCl8fFxuRmFpbCBgbmVzdGVkIHRvVGhyb3dhYmxlIGNvZXJjaW9uIG5vdCB5ZXQgc3VwcG9ydGVkICR7dmFsfWA7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRnPS8qKiBAdHlwZSB7Q29weVRhZ2dlZH0gKi9zcGVjaW1lbjtcbmNvbnN0e3BheWxvYWR9PXRnO1xucGF5bG9hZD09PXRvVGhyb3dhYmxlKHBheWxvYWQpfHxcbkZhaWwgYG5lc3RlZCB0b1Rocm93YWJsZSBjb2VyY2lvbiBub3QgeWV0IHN1cHBvcnRlZCAke3BheWxvYWR9YDtcbmJyZWFrO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVyPS8qKiBAdHlwZSB7RXJyb3J9ICovc3BlY2ltZW47XG5lcj09PXRvVGhyb3dhYmxlKGVyKXx8XG5GYWlsIGBuZXN0ZWQgdG9UaHJvd2FibGUgY29lcmNpb24gbm90IHlldCBzdXBwb3J0ZWQgJHtlcn1gO1xuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBBICR7cShwYXNzU3R5bGUpfSBpcyBub3QgdGhyb3dhYmxlOiAke3NwZWNpbWVufWA7XG4gfX1cblxuIH1cbnJldHVybiAoLyoqIEB0eXBlIHtQYXNzYWJsZTxuZXZlcixuZXZlcj59ICovc3BlY2ltZW4pO1xuIH07JGjNj19vbmNlLnRvVGhyb3dhYmxlKHRvVGhyb3dhYmxlKTtcbmhhcmRlbih0b1Rocm93YWJsZSk7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCI6WyJQYXNzU3R5bGVPZkVuZG93bWVudFN5bWJvbCJdLCJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdLCJpc1Bhc3NhYmxlIjpbImlzUGFzc2FibGUiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdLCJ0b1Rocm93YWJsZSI6WyJ0b1Rocm93YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACC5ALHEiIAABIiAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyJAZW5kby9lcnJvcnMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEsYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxoYXNPd25Qcm9wZXJ0eU9mLFBBU1NfU1RZTEUsY2hlY2tUYWdSZWNvcmQsY2hlY2tGdW5jdGlvblRhZ1JlY29yZCxpc09iamVjdCxnZXRUYWcsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaM2PX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaM2PX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRozY9fYSA9PiAoY2FuQmVNZXRob2QgPSAkaM2PX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjNj19hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjNj19hID0+IChjaGVja1RhZ1JlY29yZCA9ICRozY9fYSldXSxbXCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQgPSAkaM2PX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRozY9fYSA9PiAoaXNPYmplY3QgPSAkaM2PX2EpXV0sW1wiZ2V0VGFnXCIsIFskaM2PX2EgPT4gKGdldFRhZyA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAaW1wb3J0IHtDaGVja2VyfSBmcm9tICcuL3R5cGVzLmpzJ1xuICogQGltcG9ydCB7SW50ZXJmYWNlU3BlYywgUGFzc1N0eWxlZH0gZnJvbSAnLi90eXBlcy5qcydcbiAqIEBpbXBvcnQge1Bhc3NTdHlsZUhlbHBlcn0gZnJvbSAnLi9pbnRlcm5hbC10eXBlcy5qcydcbiAqIEBpbXBvcnQge1JlbW90YWJsZU9iamVjdCBhcyBSZW1vdGFibGV9IGZyb20gJy4vdHlwZXMuanMnXG4gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZSxcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICovXG5jb25zdCBjaGVja0lmYWNlPShpZmFjZSxjaGVjayk9PntcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRm9yIG5vdywgaW50ZXJmYWNlICR7aWZhY2V9IG11c3QgYmUgYSBzdHJpbmc7IHVuaW1wbGVtZW50ZWRgKSYmKFxuaWZhY2U9PT0nUmVtb3RhYmxlJ3x8XG5pZmFjZS5zdGFydHNXaXRoKCdBbGxlZ2VkOiAnKXx8XG5pZmFjZS5zdGFydHNXaXRoKCdEZWJ1Z05hbWU6ICcpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGb3Igbm93LCBpZmFjZSAke3EoXG5pZmFjZSlcbiB9IG11c3QgYmUgXCJSZW1vdGFibGVcIiBvciBiZWdpbiB3aXRoIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiOyB1bmltcGxlbWVudGVkYCkpO1xuXG4gfTtcblxuLyoqXG4gKiBBbiBgaWZhY2VgIG11c3QgYmUgcHVyZS4gUmlnaHQgbm93IGl0IG11c3QgYmUgYSBzdHJpbmcsIHdoaWNoIGlzIHB1cmUuXG4gKiBMYXRlciB3ZSBleHBlY3QgdG8gaW5jbHVkZSBzb21lIG90aGVyIHZhbHVlcyB0aGF0IHF1YWxpZnkgYXMgYFB1cmVEYXRhYCxcbiAqIHdoaWNoIGlzIGEgcGFzcy1ieS1jb3B5IHN1cGVyc3RydWN0dXJlIGVuZGluZyBvbmx5IGluIHByaW1pdGl2ZXMgb3JcbiAqIGVtcHR5IHBhc3MtYnktY29weSBjb21wb3NpdGVzLiBObyByZW1vdGFibGVzLCBwcm9taXNlcywgb3IgZXJyb3JzLlxuICogV2UgKmFzc3VtZSogZm9yIG5vdyB0aGF0IHRoZSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgY29udGFpbnMgbm9cbiAqIHByb3hpZXMuXG4gKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0SWZhY2U9KGlmYWNlKT0+Y2hlY2tJZmFjZShpZmFjZSxhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmlzT2JqZWN0KG9yaWdpbmFsKXx8XG5GYWlsIGBSZW1vdGFibGVzIG11c3QgYmUgb2JqZWN0cyBvciBmdW5jdGlvbnM6ICR7b3JpZ2luYWx9YDtcblxuLyogQSB2YWxpZCByZW1vdGFibGUgb2JqZWN0IG11c3QgaW5oZXJpdCBmcm9tIGEgXCJ0YWcgcmVjb3JkXCIgLS0gYSovXG4vKiBwbGFpbi1vYmplY3QgcHJvdG90eXBlIGNvbnNpc3Rpbmcgb2Ygb25seSovXG4vKiBhIGBQQVNTX1NUWUxFYCBwcm9wZXJ0eSB3aXRoIHZhbHVlIFwicmVtb3RhYmxlXCIgYW5kIGEgc3VpdGFibGUgYFN5bWJvbC50b1N0cmluZ1RhZ2AqL1xuLyogcHJvcGVydHkuIFRoZSByZW1vdGFibGUgY291bGQgaW5oZXJpdCBkaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLCBvciovXG4vKiBpdCBjb3VsZCBpbmhlcml0IGZyb20gYW5vdGhlciB2YWxpZCByZW1vdGFibGUsIHRoYXQgdGhlcmVmb3JlIGl0c2VsZiovXG4vKiBpbmhlcml0cyBkaXJlY3RseSBvciBpbmRpcmVjdGx5IGZyb20gc3VjaCBhIHRhZyByZWNvcmQuKi9cbi8qKi9cbi8qIFRPRE86IEl0IHdvdWxkIGJlIG5pY2UgdG8gdHlwZWRlZiB0aGlzIHNoYXBlLCBidXQgd2UgY2FuJ3QgZGVjbGFyZSBhIHR5cGUqL1xuLyogd2l0aCBQQVNTX1NUWUxFIGZyb20gSlNEb2MuKi9cbi8qKi9cbi8qIEB0eXBlIHt7IFtQQVNTX1NUWUxFXTogc3RyaW5nLCovXG4vKiBbU3ltYm9sLnRvU3RyaW5nVGFnXTogc3RyaW5nLCovXG4vKiB9fSovXG4vKiovXG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihvcmlnaW5hbCk7XG5pZihcbnByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxcbnByb3RvPT09bnVsbHx8XG5wcm90bz09PUZ1bmN0aW9uLnByb3RvdHlwZSlcbntcbnJldHVybihcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBSZW1vdGFibGVzIG11c3QgYmUgZXhwbGljaXRseSBkZWNsYXJlZDogJHtxKG9yaWdpbmFsKX1gKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxuISFjaGVjayYmXG5DWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gUmVtb3RhYmxlIFByb3RvICR7b3duS2V5cyhyZXN0RGVzY3MpfWApJiZcbmNoZWNrSWZhY2UoaWZhY2UsY2hlY2spKTtcblxuIH07XG5cbi8qKlxuICogS2VlcCBhIHdlYWsgc2V0IG9mIGNvbmZpcm1lZCByZW1vdGFibGVzIGZvciBtYXJzaGFsIHBlcmZvcm1hbmNlXG4gKiAod2l0aG91dCB3aGljaCB3ZSB3b3VsZCBpbmN1ciBhIHJlZHVuZGFudCB2ZXJpZmljYXRpb24gaW5cbiAqIGdldEludGVyZmFjZU9mKS5cbiAqIFdlIGRvbid0IHJlbWVtYmVyIHJlamVjdGlvbnMgYmVjYXVzZSB0aGV5IGFyZSBwb3NzaWJsZSB0byBjb3JyZWN0XG4gKiB3aXRoIGUuZy4gYGhhcmRlbmAuXG4gKlxuICogQHR5cGUge1dlYWtTZXQ8UmVtb3RhYmxlPn1cbiAqL1xuY29uc3QgY29uZmlybWVkUmVtb3RhYmxlcz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge3ZhbCBpcyBSZW1vdGFibGV9XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlPSh2YWwsY2hlY2spPT57XG5pZihjb25maXJtZWRSZW1vdGFibGVzLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybihcbiEhY2hlY2smJkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke3ZhbH1gKTtcblxuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIFNpbXBsZSBzZW1hbnRpY3MsIGp1c3QgdGVsbCB3aGF0IGludGVyZmFjZSBzcGVjIGEgUmVtb3RhYmxlIGhhcyxcbiAqIG9yIHVuZGVmaW5lZCBpZiBub3QgZGVlbWVkIHRvIGJlIGEgUmVtb3RhYmxlLlxuICpcbiAqIEB0eXBlIHt7XG4gKiA8VCBleHRlbmRzIHN0cmluZz4odmFsOiBQYXNzU3R5bGVkPGFueSwgVD4pOiBUO1xuICogKHZhbDogYW55KTogSW50ZXJmYWNlU3BlYyB8IHVuZGVmaW5lZDtcbiAqIH19XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbi8qIEB0cy1leHBlY3QtZXJyb3IgbmFycm93ZWQqL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIG5hcnJvd2VkKi9cbnJldHVybiBnZXRUYWcodmFsKTtcbiB9OyRozY9fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCB2YWxpZFR5cGU9XG4oaXNPYmplY3QoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgY2Fubm90IHNlcmlhbGl6ZSBub24tb2JqZWN0cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgYXJyYXlzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKTtcbmlmKCF2YWxpZFR5cGUpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xuaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdvYmplY3QnKXtcbi8qIEV2ZXJ5IG93biBwcm9wZXJ0eSAocmVnYXJkbGVzcyBvZiBlbnVtZXJhYmlsaXR5KSovXG4vKiBtdXN0IGhhdmUgYSBmdW5jdGlvbiB2YWx1ZS4qL1xucmV0dXJuIG93bktleXMoZGVzY3MpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4vKiBUeXBlY2FzdCBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG4oaGFzT3duUHJvcGVydHlPZihkZXNjc1svKiogQHR5cGUge3N0cmluZ30gKi9rZXldLCd2YWx1ZScpfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBjYW5ub3Qgc2VyaWFsaXplIFJlbW90YWJsZXMgd2l0aCBhY2Nlc3NvcnMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApJiYoXG5rZXk9PT1TeW1ib2wudG9TdHJpbmdUYWcmJmNoZWNrSWZhY2UoY2FuZGlkYXRlW2tleV0sY2hlY2spfHxcbihjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFjaGVjayYmXG5DWChjaGVjaykgYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIG5vbi1tZXRob2RzIGxpa2UgJHtxKFxuU3RyaW5nKGtleSkpXG4gfSBpbiAke2NhbmRpZGF0ZX1gKSYmKFxua2V5IT09UEFTU19TVFlMRXx8XG4hIWNoZWNrJiZcbkNYKGNoZWNrKSBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpO1xuXG4gfSk7XG4gfWVsc2UgaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdmdW5jdGlvbicpe1xuLyogRmFyIGZ1bmN0aW9ucyBjYW5ub3QgYmUgbWV0aG9kcywgYW5kIGNhbm5vdCBoYXZlIG1ldGhvZHMuKi9cbi8qIFRoZXkgbXVzdCBoYXZlIGV4YWN0bHkgZXhwZWN0ZWQgYC5uYW1lYCBhbmQgYC5sZW5ndGhgIHByb3BlcnRpZXMqL1xuY29uc3R7XG5uYW1lOm5hbWVEZXNjLFxubGVuZ3RoOmxlbmd0aERlc2MsXG4vKiBAdHMtaWdub3JlIFRTIGRvZXNuJ3QgbGlrZSBzeW1ib2xzIGFzIGNvbXB1dGVkIGluZGV4ZXM/PyovXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp0b1N0cmluZ1RhZ0Rlc2MsXG4uLi5yZXN0RGVzY3N9PVxuZGVzY3M7XG5jb25zdCByZXN0S2V5cz1vd25LZXlzKHJlc3REZXNjcyk7XG5yZXR1cm4oXG4obmFtZURlc2MmJnR5cGVvZiBuYW1lRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goY2hlY2spIGBGYXIgZnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbiBsZW5ndGggbXVzdCBiZSBhIG51bWJlciwgaW4gJHtjYW5kaWRhdGV9YCkmJihcbnRvU3RyaW5nVGFnRGVzYz09PXVuZGVmaW5lZHx8XG4odHlwZW9mIHRvU3RyaW5nVGFnRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbiEhY2hlY2smJlxuQ1goXG5jaGVjaylcbiBgRmFyIGZ1bmN0aW9uIEBAdG9TdHJpbmdUYWcgbXVzdCBiZSBhIHN0cmluZywgaW4gJHtjYW5kaWRhdGV9YCkmJlxuY2hlY2tJZmFjZSh0b1N0cmluZ1RhZ0Rlc2MudmFsdWUsY2hlY2spKSYmKFxucmVzdEtleXMubGVuZ3RoPT09MHx8XG4hIWNoZWNrJiZcbkNYKFxuY2hlY2spXG4gYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSk7XG5cbiB9XG5yZXR1cm4hIWNoZWNrJiZDWChjaGVjaykgYHVucmVjb2duaXplZCB0eXBlb2YgJHtjYW5kaWRhdGV9YDtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaM2PX29uY2UuUmVtb3RhYmxlSGVscGVyKFJlbW90YWJsZUhlbHBlcik7XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJZmFjZSI6WyJhc3NlcnRJZmFjZSJdLCJnZXRJbnRlcmZhY2VPZiI6WyJnZXRJbnRlcmZhY2VPZiJdLCJSZW1vdGFibGVIZWxwZXIiOlsiUmVtb3RhYmxlSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAARGFca6FAAAuhQAACsAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc2FmZS1wcm9taXNlLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbImFzc2VydFNhZmVQcm9taXNlIiwiaXNTYWZlUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBpc1Byb21pc2UscSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2YsQ1g7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wiaXNQcm9taXNlXCIsIFskaM2PX2EgPT4gKGlzUHJvbWlzZSA9ICRozY9fYSldXV1dLFtcIkBlbmRvL2Vycm9yc1wiLCBbW1wicVwiLCBbJGjNj19hID0+IChxID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRozY9fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRozY9fYSldXSxbXCJDWFwiLCBbJGjNj19hID0+IChDWCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEBpbXBvcnQge0NoZWNrZXJ9IGZyb20gJy4vdHlwZXMuanMnICovXG5cbmNvbnN0e2lzRnJvemVuLGdldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e3RvU3RyaW5nVGFnfT1TeW1ib2w7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCBrZXlzPW93bktleXMocHIpO1xuXG5pZihrZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG4vKipcbiAqIFRoaXMgZXhjbHVkZXMgdGhvc2Ugc3ltYm9sLW5hbWVkIG93biBwcm9wZXJ0aWVzIHRoYXQgYXJlIGFsc28gZm91bmQgb25cbiAqIGBQcm9taXNlLnByb3RvdHlwZWAsIHNvIHRoYXQgb3ZlcnJpZGVzIG9mIHRoZXNlIHByb3BlcnRpZXMgY2FuIGJlXG4gKiBleHBsaWNpdGx5IHRvbGVyYXRlZCBpZiB0aGV5IHBhc3MgdGhlIGBjaGVja1NhZmVPd25LZXlgIGNoZWNrIGJlbG93LlxuICogSW4gcGFydGljdWxhciwgd2Ugd2lzaCB0byB0b2xlcmF0ZVxuICogICAqIEFuIG92ZXJyaWRpbmcgYHRvU3RyaW5nVGFnYCBub24tZW51bWVyYWJsZSBkYXRhIHByb3BlcnR5XG4gKiAgICAgd2l0aCBhIHN0cmluZyB2YWx1ZS5cbiAqICAgKiBUaG9zZSBvd24gcHJvcGVydGllcyB0aGF0IG1pZ2h0IGJlIGFkZGVkIGJ5IE5vZGUncyBhc3luY19ob29rcy5cbiAqL1xuY29uc3QgdW5rbm93bktleXM9a2V5cy5maWx0ZXIoXG4oa2V5KT0+dHlwZW9mIGtleSE9PSdzeW1ib2wnfHwhaGFzT3duUHJvcGVydHlPZihQcm9taXNlLnByb3RvdHlwZSxrZXkpKTtcblxuXG5pZih1bmtub3duS2V5cy5sZW5ndGghPT0wKXtcbnJldHVybiBDWChcbmNoZWNrKVxuIGAke3ByfSAtIE11c3Qgbm90IGhhdmUgYW55IG93biBwcm9wZXJ0aWVzOiAke3EodW5rbm93bktleXMpfWA7XG4gfVxuXG4vKipcbiAqIEV4cGxpY2l0bHkgdG9sZXJhdGUgYSBgdG9TdHJpbmdUYWdgIHN5bWJvbC1uYW1lZCBub24tZW51bWVyYWJsZVxuICogZGF0YSBwcm9wZXJ0eSB3aG9zZSB2YWx1ZSBpcyBhIHN0cmluZy4gT3RoZXJ3aXNlLCB0b2xlcmF0ZSB0aG9zZVxuICogc3ltYm9sLW5hbWVkIHByb3BlcnRpZXMgdGhhdCBtaWdodCBiZSBhZGRlZCBieSBOb2RlSlMncyBhc3luY19ob29rcyxcbiAqIGlmIHRoZXkgb2JleSB0aGUgZXhwZWN0ZWQgc2FmZXR5IHByb3BlcnRpZXMuXG4gKlxuICogQXQgdGhlIHRpbWUgb2YgdGhpcyB3cml0aW5nLCBOb2RlJ3MgYXN5bmNfaG9va3MgY29udGFpbnMgdGhlXG4gKiBmb2xsb3dpbmcgY29kZSwgd2hpY2ggd2UgY2FuIHNhZmVseSB0b2xlcmF0ZVxuICpcbiAqIGBgYGpzXG4gKiBmdW5jdGlvbiBkZXN0cm95VHJhY2tpbmcocHJvbWlzZSwgcGFyZW50KSB7XG4gKiAgIHRyYWNrUHJvbWlzZShwcm9taXNlLCBwYXJlbnQpO1xuICogICBjb25zdCBhc3luY0lkID0gcHJvbWlzZVthc3luY19pZF9zeW1ib2xdO1xuICogICBjb25zdCBkZXN0cm95ZWQgPSB7IGRlc3Ryb3llZDogZmFsc2UgfTtcbiAqICAgcHJvbWlzZVtkZXN0cm95ZWRTeW1ib2xdID0gZGVzdHJveWVkO1xuICogICByZWdpc3RlckRlc3Ryb3lIb29rKHByb21pc2UsIGFzeW5jSWQsIGRlc3Ryb3llZCk7XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGtleVxuICovXG5jb25zdCBjaGVja1NhZmVPd25LZXk9KGtleSk9PntcbmlmKGtleT09PXRvU3RyaW5nVGFnKXtcbi8qIFRPRE8gc2hvdWxkIHdlIGFsc28gZW5mb3JjZSBhbnl0aGluZyBvbiB0aGUgY29udGVudHMgb2YgdGhlIHN0cmluZywqL1xuLyogc3VjaCBhcyB0aGF0IGl0IG11c3Qgc3RhcnQgd2l0aCBgJ1Byb21pc2UnYD8qL1xuY29uc3QgdGFnRGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IocHIsdG9TdHJpbmdUYWcpO1xuYXNzZXJ0KHRhZ0Rlc2MhPT11bmRlZmluZWQpO1xucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YodGFnRGVzYywndmFsdWUnKXx8XG5DWChcbmNoZWNrKVxuIGBPd24gQEB0b1N0cmluZ1RhZyBtdXN0IGJlIGEgZGF0YSBwcm9wZXJ0eSwgbm90IGFuIGFjY2Vzc29yOiAke3EodGFnRGVzYyl9YCkmJihcbnR5cGVvZiB0YWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxuQ1goXG5jaGVjaylcbiBgT3duIEBAdG9TdHJpbmdUYWcgdmFsdWUgbXVzdCBiZSBhIHN0cmluZzogJHtxKHRhZ0Rlc2MudmFsdWUpfWApJiYoXG4hdGFnRGVzYy5lbnVtZXJhYmxlfHxcbkNYKGNoZWNrKSBgT3duIEBAdG9TdHJpbmdUYWcgbXVzdCBub3QgYmUgZW51bWVyYWJsZTogJHtxKHRhZ0Rlc2MpfWApKTtcblxuIH1cbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBDWChcbmNoZWNrKVxuIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YDtcbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVPd25LZXkpO1xuIH07XG5cbi8qKlxuICogVW5kZXIgSGFyZGVuZWQgSlMgYSBwcm9taXNlIGlzIFwic2FmZVwiIGlmIGl0cyBgdGhlbmAgbWV0aG9kIGNhbiBiZSBjYWxsZWRcbiAqIHN5bmNocm9ub3VzbHkgd2l0aG91dCBnaXZpbmcgdGhlIHByb21pc2UgYW4gb3Bwb3J0dW5pdHkgZm9yIGFcbiAqIHJlZW50cmFuY3kgYXR0YWNrIGR1cmluZyB0aGF0IGNhbGwuXG4gKlxuICogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy85XG4gKiByYWlzZXMgdGhlIGlzc3VlIG9mIHRlc3RpbmcgdGhhdCBhIHNwZWNpbWVuIGlzIGEgc2FmZSBwcm9taXNlXG4gKiBzdWNoIHRoYXQgdGhlIHRlc3QgYWxzbyBkb2VzIG5vdCBnaXZlIHRoZSBzcGVjaW1lbiBhXG4gKiByZWVudHJhbmN5IG9wcG9ydHVuaXR5LiBUaGF0IGlzIHdlbGwgYmV5b25kIHRoZSBhbWJpdGlvbiBoZXJlLlxuICogVE9ETyBUaG91Z2ggaWYgd2UgZmlndXJlIG91dCBhIG5pY2Ugc29sdXRpb24sIGl0IG1pZ2h0IGJlIGdvb2QgdG9cbiAqIHVzZSBpdCBoZXJlIGFzIHdlbGwuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tTYWZlUHJvbWlzZT0ocHIsY2hlY2spPT57XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxDWChjaGVjaykgYCR7cHJ9IC0gTXVzdCBiZSBmcm96ZW5gKSYmKFxuaXNQcm9taXNlKHByKXx8Q1goY2hlY2spIGAke3ByfSAtIE11c3QgYmUgYSBwcm9taXNlYCkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbkNYKGNoZWNrKSBgJHtwcn0gLSBNdXN0IGluaGVyaXQgZnJvbSBQcm9taXNlLnByb3RvdHlwZTogJHtxKFxuZ2V0UHJvdG90eXBlT2YocHIpKVxuIH1gKSYmXG5jaGVja1Byb21pc2VPd25LZXlzKC8qKiBAdHlwZSB7UHJvbWlzZX0gKi9wcixjaGVjaykpO1xuXG4gfTtcbmhhcmRlbihjaGVja1NhZmVQcm9taXNlKTtcblxuLyoqXG4gKiBEZXRlcm1pbmUgaWYgdGhlIGFyZ3VtZW50IGlzIGEgUHJvbWlzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHByIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7cHIgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHByb21pc2VcbiAqL1xuY29uc3QgICAgICAgIGlzU2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwciwoeCk9PngpOyRozY9fb25jZS5pc1NhZmVQcm9taXNlKGlzU2FmZVByb21pc2UpO1xuaGFyZGVuKGlzU2FmZVByb21pc2UpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0U2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwcixhc3NlcnRDaGVja2VyKTskaM2PX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNTYWZlUHJvbWlzZSI6WyJpc1NhZmVQcm9taXNlIl0sImFzc2VydFNhZmVQcm9taXNlIjpbImFzc2VydFNhZmVQcm9taXNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEAKso4UDwAAFA8AACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3RyaW5nLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vudi1vcHRpb25zIiwiQGVuZG8vZXJyb3JzIl0sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTdHJpbmciLCJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIiwiaXNXZWxsRm9ybWVkU3RyaW5nIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgbGV0IGdldEVudmlyb25tZW50T3B0aW9uLEZhaWw7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wiZ2V0RW52aXJvbm1lbnRPcHRpb25cIiwgWyRozY9fYSA9PiAoZ2V0RW52aXJvbm1lbnRPcHRpb24gPSAkaM2PX2EpXV1dXSxbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoga25vdyBhYm91dGBpc1dlbGxGb3JtZWRgKi9cbmNvbnN0IGhhc1dlbGxGb3JtZWRTdHJpbmdNZXRob2Q9ISFTdHJpbmcucHJvdG90eXBlLmlzV2VsbEZvcm1lZDtcblxuLyoqXG4gKiBJcyB0aGUgYXJndW1lbnQgYSB3ZWxsLWZvcm1lZCBzdHJpbmc/XG4gKlxuICogVW5mb3J0dW5hdGVseSwgdGhlXG4gKiBbc3RhbmRhcmQgYnVpbHQtaW4gYFN0cmluZy5wcm90b3R5cGUuaXNXZWxsRm9ybWVkYF0oaHR0cHM6Ly9naXRodWIuY29tL3RjMzkvcHJvcG9zYWwtaXMtdXN2LXN0cmluZylcbiAqIGRvZXMgYSBUb1N0cmluZyBvbiBpdHMgaW5wdXQsIGNhdXNpbmcgaXQgdG8ganVkZ2Ugbm9uLXN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MgaWYgdGhleSBjb2VyY2UgdG8gYSB3ZWxsLWZvcm1lZCBzdHJpbmdzLiBUaGlzXG4gKiByZWNhcGl0dWxhdGVzIHRoZSBtaXN0YWtlIGluIGhhdmluZyB0aGUgZ2xvYmFsIGBpc05hTmAgY29lcmNlIGl0cyBpbnB1dHMsXG4gKiBjYXVzaW5nIGl0IHRvIGp1ZGdlIG5vbi1zdHJpbmcgdG8gYmUgTmFOIGlmIHRoZXkgY29lcmNlIHRvIE5hTi5cbiAqXG4gKiBUaGlzIGBpc1dlbGxGb3JtZWRTdHJpbmdgIGZ1bmN0aW9uIG9ubHkganVkZ2VzIHdlbGwtZm9ybWVkIHN0cmluZ3MgdG8gYmVcbiAqIHdlbGwtZm9ybWVkIHN0cmluZ3MuIEZvciBhbGwgbm9uLXN0cmluZ3MgaXQgcmV0dXJucyBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge3N0ciBpcyBzdHJpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBpc1dlbGxGb3JtZWRTdHJpbmc9aGFzV2VsbEZvcm1lZFN0cmluZ01ldGhvZD9cbihzdHIpPT50eXBlb2Ygc3RyPT09J3N0cmluZycmJnN0ci5pc1dlbGxGb3JtZWQoKTpcbihzdHIpPT57XG5pZih0eXBlb2Ygc3RyIT09J3N0cmluZycpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmZvcihjb25zdCBjaCBvZiBzdHIpe1xuLyogVGhlIHN0cmluZyBpdGVyYXRvciBpdGVyYXRlcyBieSBVbmljb2RlIGNvZGUgcG9pbnQsIG5vdCovXG4vKiBVVEYxNiBjb2RlIHVuaXQuIEJ1dCBpZiBpdCBlbmNvdW50ZXJzIGFuIHVucGFpcmVkIHN1cnJvZ2F0ZSwqL1xuLyogaXQgd2lsbCBwcm9kdWNlIGl0LiovXG5jb25zdCBjcD0vKiogQHR5cGUge251bWJlcn0gKi9jaC5jb2RlUG9pbnRBdCgwKTtcbmlmKGNwPj0weGQ4MDAmJmNwPD0weGRmZmYpe1xuLyogQWxsIHN1cnJvZ2F0ZXMgYXJlIGluIHRoaXMgcmFuZ2UuIFRoZSBzdHJpbmcgaXRlcmF0b3Igb25seSovXG4vKiBwcm9kdWNlcyBhIGNoYXJhY3RlciBpbiB0aGlzIHJhbmdlIGZvciB1bnBhaXJlZCBzdXJyb2dhdGVzLCovXG4vKiB3aGljaCBvbmx5IGhhcHBlbnMgaWYgdGhlIHN0cmluZyBpcyBub3Qgd2VsbC1mb3JtZWQuKi9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTskaM2PX29uY2UuaXNXZWxsRm9ybWVkU3RyaW5nKGlzV2VsbEZvcm1lZFN0cmluZyk7XG5oYXJkZW4oaXNXZWxsRm9ybWVkU3RyaW5nKTtcblxuLyoqXG4gKiBSZXR1cm5zIG5vcm1hbGx5IHdoZW4gYGlzV2VsbEZvcm1lZFN0cmluZyhzdHIpYCB3b3VsZCByZXR1cm4gdHJ1ZS5cbiAqIFRocm93cyBhIGRpYWdub3N0aWMgZXJyb3Igd2hlbiBgaXNXZWxsRm9ybWVkU3RyaW5nKHN0cilgIHdvdWxkIHJldHVybiBmYWxzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHN0clxuICogQHJldHVybnMge2Fzc2VydHMgc3RyIGlzIHN0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFdlbGxGb3JtZWRTdHJpbmc9KHN0cik9PntcbmlzV2VsbEZvcm1lZFN0cmluZyhzdHIpfHxGYWlsIGBFeHBlY3RlZCB3ZWxsLWZvcm1lZCB1bmljb2RlIHN0cmluZzogJHtzdHJ9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRXZWxsRm9ybWVkU3RyaW5nKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFdlbGxGb3JtZWRTdHJpbmcpO1xuXG5jb25zdCBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEU9XG5nZXRFbnZpcm9ubWVudE9wdGlvbignT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFJywnZGlzYWJsZWQnLFtcbidlbmFibGVkJ10pPT09XG4nZW5hYmxlZCc7XG5cbi8qKlxuICogRm9yIG5vdyxcbiAqIGlmIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGVudmlyb25tZW50IG9wdGlvbiBpcyBgJ2VuYWJsZWQnYCxcbiAqIHRoZW4gYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBpcyB0aGUgc2FtZSBhcyBgYXNzZXJ0V2VsbEZvcm1lZFN0cmluZ2AuXG4gKiBPdGhlcndpc2UgYGFzc2VydFBhc3NhYmxlU3RyaW5nYCBqdXN0IGFzc2VydHMgdGhhdCBgc3RyYCBpcyBhIHN0cmluZy5cbiAqXG4gKiBDdXJyZW50bHksIGBPTkxZX1dFTExfRk9STUVEX1NUUklOR1NfUEFTU0FCTEVgIGRlZmF1bHRzIHRvIGAnZGlzYWJsZWQnYFxuICogYmVjYXVzZSB3ZSBkbyBub3QgeWV0IGtub3cgdGhlIHBlcmZvcm1hbmNlIGltcGFjdC4gTGF0ZXIsIGlmIHdlIGRlY2lkZSB3ZVxuICogY2FuIGFmZm9yZCBpdCwgd2UnbGwgZmlyc3QgY2hhbmdlIHRoZSBkZWZhdWx0IHRvIGAnZW5hYmxlZCdgIGFuZCB1bHRpbWF0ZWx5XG4gKiByZW1vdmUgdGhlIHN3aXRjaCBhbHRvZ2V0aGVyLiBCZSBwcmVwYXJlZCBmb3IgdGhlc2UgY2hhbmdlcy5cbiAqXG4gKiBUT0RPIG9uY2UgdGhlIHN3aXRjaCBpcyByZW1vdmVkLCBzaW1wbGlmeSBgYXNzZXJ0UGFzc2FibGVTdHJpbmdgIHRvXG4gKiBzaW1wbHkgYmUgYGFzc2VydFdlbGxGb3JtZWRTdHJpbmdgLlxuICpcbiAqIEBwYXJhbSB7IHVua25vd24gfSBzdHJcbiAqIEByZXR1cm5zIHthc3NlcnRzIHN0ciBpcyBzdHJpbmcgfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTdHJpbmc9KHN0cik9PntcbnR5cGVvZiBzdHI9PT0nc3RyaW5nJ3x8RmFpbCBgRXhwZWN0ZWQgc3RyaW5nICR7c3RyfWA7XG4hT05MWV9XRUxMX0ZPUk1FRF9TVFJJTkdTX1BBU1NBQkxFfHxhc3NlcnRXZWxsRm9ybWVkU3RyaW5nKHN0cik7XG4gfTskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTdHJpbmcoYXNzZXJ0UGFzc2FibGVTdHJpbmcpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3RyaW5nKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzV2VsbEZvcm1lZFN0cmluZyI6WyJpc1dlbGxGb3JtZWRTdHJpbmciXSwiYXNzZXJ0V2VsbEZvcm1lZFN0cmluZyI6WyJhc3NlcnRXZWxsRm9ybWVkU3RyaW5nIl0sImFzc2VydFBhc3NhYmxlU3RyaW5nIjpbImFzc2VydFBhc3NhYmxlU3RyaW5nIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMs77KO4EgAAuBIAACUAAABAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3ltYm9sLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2Vycm9ycyJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHE7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXV0pOyAgIFxuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjNj19vbmNlLmlzUGFzc2FibGVTeW1ib2woaXNQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oaXNQYXNzYWJsZVN5bWJvbCk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZVN5bWJvbD0oc3ltKT0+XG5pc1Bhc3NhYmxlU3ltYm9sKHN5bSl8fFxuRmFpbCBgT25seSByZWdpc3RlcmVkIHN5bWJvbHMgb3Igd2VsbC1rbm93biBzeW1ib2xzIGFyZSBwYXNzYWJsZTogJHtxKHN5bSl9YDskaM2PX29uY2UuYXNzZXJ0UGFzc2FibGVTeW1ib2woYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3ltYm9sKTtcblxuLyoqXG4gKiBJZiBgc3ltYCBpcyBhIHBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGEgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzXG4gKiBzeW1ib2wuIElmIGBzeW1gIGlzIGEgbm9uLXBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGB1bmRlZmluZWRgLlxuICpcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuIFNpbmNlIHRoZSByZWdpc3RyYXRpb24gc3RyaW5nIG9mIGEgcmVnaXN0ZXJlZCBzeW1ib2wgY2FuIGJlIGFueVxuICogc3RyaW5nLCBpZiB3ZSBzaW1wbHkgdXNlZCB0aGF0IHRvIGlkZW50aWZ5IHRob3NlIHN5bWJvbHMsIHRoZXJlIHdvdWxkIG5vdFxuICogYmUgYW55IHJlbWFpbmluZyBzdHJpbmdzIGxlZnQgb3ZlciB0byBpZGVudGlmeSB0aGUgd2VsbC1rbm93biBzeW1ib2xzLlxuICogSW5zdGVhZCwgd2UgcmVzZXJ2ZSBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGBcIkBAXCJgIGZvciBwdXJwb3NlcyBvZiB0aGlzXG4gKiBlbmNvZGluZy4gV2UgaWRlbnRpZnkgYSB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiBieSBwcmVmaXhpbmcgdGhlIHByb3BlcnR5IG5hbWUgd2l0aCBgXCJAQFwiYCwgc3VjaCBhcyBgXCJAQGl0ZXJhdG9yXCJgLlxuICogRm9yIHJlZ2lzdGVyZWQgc3ltYm9scyB3aG9zZSBuYW1lIGhhcHBlbnMgdG8gYmVnaW4gd2l0aCBgXCJAQFwiYCwgc3VjaFxuICogYXMgYFN5bWJvbC5mb3IoJ0BAaXRlcmF0b3InKWAgb3IgYFN5bWJvbC5mb3IoJ0BAZm9vJylgLCB3ZSBpZGVudGlmeVxuICogdGhlbSBieSBwcmVmaXhpbmcgdGhlbSB3aXRoIGFuIGV4dHJhIGBcIkBAXCJgLCBzdWNoIGFzXG4gKiBgXCJAQEBAaXRlcmF0b3JcImAgb3IgYFwiQEBAQGZvb1wiYC4gKFRoaXMgaXMgdGhlIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmdcbiAqIHRlY2huaXF1ZS4pXG4gKlxuICogQHBhcmFtIHtzeW1ib2x9IHN5bVxuICogQHJldHVybnMge3N0cmluZz19XG4gKi9cbmNvbnN0ICAgICAgICBuYW1lRm9yUGFzc2FibGVTeW1ib2w9KHN5bSk9PntcbmNvbnN0IG5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYobmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gd2VsbEtub3duU3ltYm9sTmFtZXMuZ2V0KHN5bSk7XG4gfVxuaWYobmFtZS5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBgQEAke25hbWV9YDtcbiB9XG5yZXR1cm4gbmFtZTtcbiB9OyRozY9fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaM2PX29uY2UucGFzc2FibGVTeW1ib2xGb3JOYW1lKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG5oYXJkZW4ocGFzc2FibGVTeW1ib2xGb3JOYW1lKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUGFzc2FibGVTeW1ib2wiOlsiaXNQYXNzYWJsZVN5bWJvbCJdLCJhc3NlcnRQYXNzYWJsZVN5bWJvbCI6WyJhc3NlcnRQYXNzYWJsZVN5bWJvbCJdLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiOlsibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sInBhc3NhYmxlU3ltYm9sRm9yTmFtZSI6WyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADBplv5UIAACVCAAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90YWdnZWQuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlRhZ2dlZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxnZXRPd25EYXRhRGVzY3JpcHRvcixjaGVja1Bhc3NTdHlsZTskaM2PX2ltcG9ydHMoW1tcIkBlbmRvL2Vycm9yc1wiLCBbW1wiRmFpbFwiLCBbJGjNj19hID0+IChGYWlsID0gJGjNj19hKV1dXV0sW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjNj19hID0+IChhc3NlcnRDaGVja2VyID0gJGjNj19hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaM2PX2EgPT4gKGNoZWNrVGFnUmVjb3JkID0gJGjNj19hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRozY9fYSA9PiAoUEFTU19TVFlMRSA9ICRozY9fYSldXSxbXCJnZXRPd25EYXRhRGVzY3JpcHRvclwiLCBbJGjNj19hID0+IChnZXRPd25EYXRhRGVzY3JpcHRvciA9ICRozY9fYSldXSxbXCJjaGVja1Bhc3NTdHlsZVwiLCBbJGjNj19hID0+IChjaGVja1Bhc3NTdHlsZSA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtJTVBPUlQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBUYWdnZWRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTondGFnZ2VkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuY2hlY2tQYXNzU3R5bGUoY2FuZGlkYXRlLGNhbmRpZGF0ZVtQQVNTX1NUWUxFXSwndGFnZ2VkJyxjaGVjayksXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNoZWNrVGFnUmVjb3JkKGNhbmRpZGF0ZSwndGFnZ2VkJyxhc3NlcnRDaGVja2VyKTtcblxuLyogVHlwZWNhc3RzIG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbmNvbnN0IHBhc3NTdHlsZUtleT0vKiogQHR5cGUge3Vua25vd259ICovUEFTU19TVFlMRTtcbmNvbnN0IHRhZ0tleT0vKiogQHR5cGUge3Vua25vd259ICovU3ltYm9sLnRvU3RyaW5nVGFnO1xuY29uc3R7XG4vKiBjaGVja1RhZ1JlY29yZCBhbHJlYWR5IHZlcmlmaWVkIFBBU1NfU1RZTEUgYW5kIFN5bWJvbC50b1N0cmluZ1RhZyBvd24gZGF0YSBwcm9wZXJ0aWVzLiovXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovcGFzc1N0eWxlS2V5XTpfcGFzc1N0eWxlRGVzYyxcblsvKiogQHR5cGUge3N0cmluZ30gKi90YWdLZXldOl9sYWJlbERlc2MsXG5wYXlsb2FkOl9wYXlsb2FkRGVzYywvKiB2YWx1ZSBjaGVja2VkIGJ5IHJlY3Vyc2l2ZSB3YWxrIGF0IHRoZSBlbmQqL1xuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg9PT0wfHxcbkZhaWwgYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiB0YWdnZWQgcmVjb3JkICR7b3duS2V5cyhyZXN0RGVzY3MpfWA7XG5cbi8qIFZhbGlkYXRlIHRoYXQgdGhlICdwYXlsb2FkJyBwcm9wZXJ0eSBpcyBvd24vZGF0YS9lbnVtZXJhYmxlKi9cbi8qIGFuZCBpdHMgYXNzb2NpYXRlZCB2YWx1ZSBpcyByZWN1cnNpdmVseSBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihcbmdldE93bkRhdGFEZXNjcmlwdG9yKGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKS52YWx1ZSk7XG5cbiB9fSk7JGjNj19vbmNlLlRhZ2dlZEhlbHBlcihUYWdnZWRIZWxwZXIpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKomXX/AsAAPwLAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXJyb3JzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYWlsLHEscGFzc1N0eWxlT2Y7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9lcnJvcnNcIiwgW1tcIkZhaWxcIiwgWyRozY9fYSA9PiAoRmFpbCA9ICRozY9fYSldXSxbXCJxXCIsIFskaM2PX2EgPT4gKHEgPSAkaM2PX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjNj19hID0+IChwYXNzU3R5bGVPZiA9ICRozY9fYSldXV1dXSk7ICAgXG5cblxuLyoqIEBpbXBvcnQge0NvcHlBcnJheSwgQ29weVJlY29yZCwgUGFzc2FibGUsIFJlbW90YWJsZU9iamVjdH0gZnJvbSAnLi90eXBlcy5qcycgKi9cblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHBhc3MtYnktY29weSBhcnJheSwgQUtBIGEgXCJjb3B5QXJyYXlcIlxuICogaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjNj19vbmNlLmlzQ29weUFycmF5KGlzQ29weUFycmF5KTtcbmhhcmRlbihpc0NvcHlBcnJheSk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBBS0EgYVxuICogXCJjb3B5UmVjb3JkXCIgaW4gQGVuZG8vbWFyc2hhbCB0ZXJtc1xuICpcbiAqIEBwYXJhbSB7YW55fSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaM2PX29uY2UuaXNSZWNvcmQoaXNSZWNvcmQpO1xuaGFyZGVuKGlzUmVjb3JkKTtcblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHJlbW90YWJsZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtyZW1vdGFibGUgaXMgUmVtb3RhYmxlT2JqZWN0fVxuICovXG5jb25zdCBpc1JlbW90YWJsZT0ocmVtb3RhYmxlKT0+cGFzc1N0eWxlT2YocmVtb3RhYmxlKT09PSdyZW1vdGFibGUnOyRozY9fb25jZS5pc1JlbW90YWJsZShpc1JlbW90YWJsZSk7XG5oYXJkZW4oaXNSZW1vdGFibGUpO1xuXG4vKipcbiAqIEBwYXJhbSB7YW55fSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaM2PX29uY2UuYXNzZXJ0Q29weUFycmF5KGFzc2VydENvcHlBcnJheSk7XG5oYXJkZW4oYXNzZXJ0Q29weUFycmF5KTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuY29uc3QgYXNzZXJ0UmVjb3JkPShyZWNvcmQsb3B0TmFtZU9mUmVjb3JkPSdBbGxlZ2VkIHJlY29yZCcpPT57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVjb3JkKTtcbnBhc3NTdHlsZT09PSdjb3B5UmVjb3JkJ3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mUmVjb3JkKX0gJHtyZWNvcmR9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgcmVjb3JkLCBub3QgJHtxKFxucGFzc1N0eWxlKVxuIH1gO1xuIH07JGjNj19vbmNlLmFzc2VydFJlY29yZChhc3NlcnRSZWNvcmQpO1xuaGFyZGVuKGFzc2VydFJlY29yZCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlbW90YWJsZVxuICogQHJldHVybnMge2Fzc2VydHMgcmVtb3RhYmxlIGlzIFJlbW90YWJsZU9iamVjdH1cbiAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRozY9fb25jZS5hc3NlcnRSZW1vdGFibGUoYXNzZXJ0UmVtb3RhYmxlKTtcbmhhcmRlbihhc3NlcnRSZW1vdGFibGUpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5QXJyYXkiOlsiaXNDb3B5QXJyYXkiXSwiaXNSZWNvcmQiOlsiaXNSZWNvcmQiXSwiaXNSZW1vdGFibGUiOlsiaXNSZW1vdGFibGUiXSwiYXNzZXJ0Q29weUFycmF5IjpbImFzc2VydENvcHlBcnJheSJdLCJhc3NlcnRSZWNvcmQiOlsiYXNzZXJ0UmVjb3JkIl0sImFzc2VydFJlbW90YWJsZSI6WyJhc3NlcnRSZW1vdGFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgXG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA7PqD1JMJAACTCQAAIQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsIi4vc3JjL21lbW8tcmFjZS5qcyIsIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VQcm9taXNlS2l0IiwicmFjZVByb21pc2VzIl0sInJlZXhwb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICBsZXQgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0LG1lbW9SYWNlOyRozY9faW1wb3J0cyhbW1wiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNcIiwgW1tcIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdFwiLCBbJGjNj19hID0+IChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQgPSAkaM2PX2EpXV1dXSxbXCIuL3NyYy9tZW1vLXJhY2UuanNcIiwgW1tcIm1lbW9SYWNlXCIsIFskaM2PX2EgPT4gKG1lbW9SYWNlID0gJGjNj19hKV1dXV0sW1wiLi9zcmMvaXMtcHJvbWlzZS5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VQcm9taXNlS2l0LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlUHJvbWlzZUtpdFwifSk7JGjNj19vbmNlLm1ha2VQcm9taXNlS2l0KG1ha2VQcm9taXNlS2l0KTtPYmplY3QuZGVmaW5lUHJvcGVydHkocmFjZVByb21pc2VzLCAnbmFtZScsIHt2YWx1ZTogXCJyYWNlUHJvbWlzZXNcIn0pOyRozY9fb25jZS5yYWNlUHJvbWlzZXMocmFjZVByb21pc2VzKTsgICBcblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gKi9cbmNvbnN0IEJlc3RQaXBlbGluYWJsZVByb21pc2U9Z2xvYmFsVGhpcy5IYW5kbGVkUHJvbWlzZXx8UHJvbWlzZTtcblxuLyoqXG4gKiBtYWtlUHJvbWlzZUtpdCgpIGJ1aWxkcyBhIFByb21pc2Ugb2JqZWN0LCBhbmQgcmV0dXJucyBhIHJlY29yZFxuICogY29udGFpbmluZyB0aGUgcHJvbWlzZSBpdHNlbGYsIGFzIHdlbGwgYXMgc2VwYXJhdGUgZmFjZXRzIGZvciByZXNvbHZpbmdcbiAqIGFuZCByZWplY3RpbmcgaXQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtJTVBPUlQoJy4vc3JjL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPn1cbiAqL1xuZnVuY3Rpb24gICAgICAgIG1ha2VQcm9taXNlS2l0KCl7XG5jb25zdHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn09bWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCk7XG5cbmNvbnN0IHByb21pc2U9bmV3IEJlc3RQaXBlbGluYWJsZVByb21pc2UoZXhlY3V0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtwcm9taXNlLHJlc29sdmUscmVqZWN0fSk7XG4gfVxuaGFyZGVuKG1ha2VQcm9taXNlS2l0KTtcblxuLyogTkI6IEFub3RoZXIgaW1wbGVtZW50YXRpb24gZm9yIFByb21pc2UucmFjZSB3b3VsZCBiZSB0byB1c2UgdGhlIHJlbGVhc2luZyBleGVjdXRvciwqL1xuLyogSG93ZXZlciB3aGlsZSBpdCB3b3VsZCBubyBsb25nZXIgbGVhayB0aGUgcmFjZWQgcHJvbWlzZSBvYmplY3RzIHRoZW1zZWx2ZXMsIGl0IHdvdWxkKi9cbi8qIHN0aWxsIGxlYWsgcmVhY3Rpb25zIG9uIHRoZSBub24tcmVzb2x2ZWQgcHJvbWlzZXMgY29udGVuZGluZyBmb3IgdGhlIHJhY2UuKi9cblxuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5mdW5jdGlvbiAgICAgICAgcmFjZVByb21pc2VzKHZhbHVlcyl7XG5yZXR1cm4gaGFyZGVuKG1lbW9SYWNlLmNhbGwoQmVzdFBpcGVsaW5hYmxlUHJvbWlzZSx2YWx1ZXMpKTtcbiB9XG5oYXJkZW4ocmFjZVByb21pc2VzKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlS2l0IjpbIm1ha2VQcm9taXNlS2l0Il0sInJhY2VQcm9taXNlcyI6WyJyYWNlUHJvbWlzZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxm7EXvQCAAD0AgAAKgAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvaXMtcHJvbWlzZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiaXNQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNQcm9taXNlLCAnbmFtZScsIHt2YWx1ZTogXCJpc1Byb21pc2VcIn0pOyRozY9fb25jZS5pc1Byb21pc2UoaXNQcm9taXNlKTsgICAvKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gbWF5YmVQcm9taXNlIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7bWF5YmVQcm9taXNlIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmZ1bmN0aW9uICAgICAgICBpc1Byb21pc2UobWF5YmVQcm9taXNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUobWF5YmVQcm9taXNlKT09PW1heWJlUHJvbWlzZTtcbiB9XG5oYXJkZW4oaXNQcm9taXNlKTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJvbWlzZSI6WyJpc1Byb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAASLuyqBcTAAAXEwAAKQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvbWVtby1yYWNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtZW1vUmFjZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgICRozY9faW1wb3J0cyhbXSk7ICAgLyogSW5pdGlhbCB2ZXJzaW9uIGF1dGhvcmVkIGJ5IEJyaWFuIEtpbTpcbmh0dHBzOi8vZ2l0aHViLmNvbS9ub2RlanMvbm9kZS9pc3N1ZXMvMTc0NjkjaXNzdWVjb21tZW50LTY4NTIxNjc3N1xuIFRoaXMgaXMgZnJlZSBhbmQgdW5lbmN1bWJlcmVkIHNvZnR3YXJlIHJlbGVhc2VkIGludG8gdGhlIHB1YmxpYyBkb21haW4uXG4gQW55b25lIGlzIGZyZWUgdG8gY29weSwgbW9kaWZ5LCBwdWJsaXNoLCB1c2UsIGNvbXBpbGUsIHNlbGwsIG9yXG5kaXN0cmlidXRlIHRoaXMgc29mdHdhcmUsIGVpdGhlciBpbiBzb3VyY2UgY29kZSBmb3JtIG9yIGFzIGEgY29tcGlsZWRcbmJpbmFyeSwgZm9yIGFueSBwdXJwb3NlLCBjb21tZXJjaWFsIG9yIG5vbi1jb21tZXJjaWFsLCBhbmQgYnkgYW55XG5tZWFucy5cbiBJbiBqdXJpc2RpY3Rpb25zIHRoYXQgcmVjb2duaXplIGNvcHlyaWdodCBsYXdzLCB0aGUgYXV0aG9yIG9yIGF1dGhvcnNcbm9mIHRoaXMgc29mdHdhcmUgZGVkaWNhdGUgYW55IGFuZCBhbGwgY29weXJpZ2h0IGludGVyZXN0IGluIHRoZVxuc29mdHdhcmUgdG8gdGhlIHB1YmxpYyBkb21haW4uIFdlIG1ha2UgdGhpcyBkZWRpY2F0aW9uIGZvciB0aGUgYmVuZWZpdFxub2YgdGhlIHB1YmxpYyBhdCBsYXJnZSBhbmQgdG8gdGhlIGRldHJpbWVudCBvZiBvdXIgaGVpcnMgYW5kXG5zdWNjZXNzb3JzLiBXZSBpbnRlbmQgdGhpcyBkZWRpY2F0aW9uIHRvIGJlIGFuIG92ZXJ0IGFjdCBvZlxucmVsaW5xdWlzaG1lbnQgaW4gcGVycGV0dWl0eSBvZiBhbGwgcHJlc2VudCBhbmQgZnV0dXJlIHJpZ2h0cyB0byB0aGlzXG5zb2Z0d2FyZSB1bmRlciBjb3B5cmlnaHQgbGF3LlxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsXG5FWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Zcbk1FUkNIQU5UQUJJTElUWSwgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC5cbklOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SXG5PVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSxcbkFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUlxuT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLlxuIEZvciBtb3JlIGluZm9ybWF0aW9uLCBwbGVhc2UgcmVmZXIgdG8gPGh0dHA6Ly91bmxpY2Vuc2Uub3JnLz5cbiovXG5cblxuXG5cblxuXG5cbmNvbnN0IGlzT2JqZWN0PSh2YWx1ZSk9Pk9iamVjdCh2YWx1ZSk9PT12YWx1ZTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgW1Q9YW55XVxuICogQHR5cGVkZWYge29iamVjdH0gRGVmZXJyZWRcbiAqIEBwcm9wZXJ0eSB7KHZhbHVlPzogSU1QT1JUKFwiLi90eXBlcy5qc1wiKS5FUmVmPFQ+ICkgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHByb3BlcnR5IHsoZXJyPzogYW55ICkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IG5ldmVyXG4gKiAgfCB7c2V0dGxlZDogZmFsc2UsIGRlZmVycmVkczogU2V0PERlZmVycmVkPn1cbiAqICB8IHtzZXR0bGVkOiB0cnVlLCBkZWZlcnJlZHM/OiB1bmRlZmluZWR9XG4gKiB9IFByb21pc2VNZW1vUmVjb3JkXG4gKi9cblxuLyogS2V5cyBhcmUgdGhlIHZhbHVlcyBwYXNzZWQgdG8gcmFjZSwgdmFsdWVzIGFyZSBhIHJlY29yZCBvZiBkYXRhIGNvbnRhaW5pbmcgYSovXG4vKiBzZXQgb2YgZGVmZXJyZWRzIGFuZCB3aGV0aGVyIHRoZSB2YWx1ZSBoYXMgc2V0dGxlZC4qL1xuLyoqIEB0eXBlIHtXZWFrTWFwPG9iamVjdCwgUHJvbWlzZU1lbW9SZWNvcmQ+fSAqL1xuY29uc3Qga25vd25Qcm9taXNlcz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZU1lbW9SZWNvcmQgfCB1bmRlZmluZWR9IHJlY29yZFxuICogQHJldHVybnMge1NldDxEZWZlcnJlZD59XG4gKi9cbmNvbnN0IG1hcmtTZXR0bGVkPShyZWNvcmQpPT57XG5pZighcmVjb3JkfHxyZWNvcmQuc2V0dGxlZCl7XG5yZXR1cm4gbmV3IFNldCgpO1xuIH1cblxuY29uc3R7ZGVmZXJyZWRzfT1yZWNvcmQ7XG5PYmplY3QuYXNzaWduKHJlY29yZCx7XG5kZWZlcnJlZHM6dW5kZWZpbmVkLFxuc2V0dGxlZDp0cnVlfSk7XG5cbk9iamVjdC5mcmVlemUocmVjb3JkKTtcbnJldHVybiBkZWZlcnJlZHM7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcmV0dXJucyB7UHJvbWlzZU1lbW9SZWNvcmR9XG4gKi9cbmNvbnN0IGdldE1lbW9SZWNvcmQ9KHZhbHVlKT0+e1xuaWYoIWlzT2JqZWN0KHZhbHVlKSl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIGEgcHJpbWl0aXZlLCBhdHRlbXB0aW5nIHRvIHVzZSBpdCBhcyBhIGtleSBpbiB0aGUqL1xuLyogd2Vha21hcCB3b3VsZCB0aHJvdyBhbiBlcnJvci4gTHVja2lseSwgaXQgaXMgc2FmZSB0byBjYWxsKi9cbi8qIGBQcm9taXNlLnJlc29sdmUoY29udGVuZGVyKS50aGVuYCBvbiBhIHByaW1pdGl2ZSB2YWx1ZSBtdWx0aXBsZSB0aW1lcyovXG4vKiBiZWNhdXNlIHRoZSBwcm9taXNlIGZ1bGZpbGxzIGltbWVkaWF0ZWx5LiBTbyB3ZSBmYWtlIGEgc2V0dGxlZCByZWNvcmQuKi9cbnJldHVybiBoYXJkZW4oe3NldHRsZWQ6dHJ1ZX0pO1xuIH1cblxubGV0IHJlY29yZD1rbm93blByb21pc2VzLmdldCh2YWx1ZSk7XG5cbmlmKCFyZWNvcmQpe1xucmVjb3JkPXtkZWZlcnJlZHM6bmV3IFNldCgpLHNldHRsZWQ6ZmFsc2V9O1xua25vd25Qcm9taXNlcy5zZXQodmFsdWUscmVjb3JkKTtcbi8qIFRoaXMgY2FsbCB0byBgdGhlbmAgaGFwcGVucyBvbmNlIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIHZhbHVlLiovXG5Qcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW4oXG4odmFsKT0+e1xuZm9yKGNvbnN0e3Jlc29sdmV9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZXNvbHZlKHZhbCk7XG4gfVxuIH0sXG4oZXJyKT0+e1xuZm9yKGNvbnN0e3JlamVjdH1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlamVjdChlcnIpO1xuIH1cbiB9KTtcblxuIH1cbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3R7cmFjZX09e1xuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIHtyZWFkb25seSB1bmtub3duW10gfCBbXX0gVFxuICogQHRlbXBsYXRlIHtQcm9taXNlQ29uc3RydWN0b3J9IFtQPVByb21pc2VDb25zdHJ1Y3Rvcl1cbiAqIEB0aGlzIHtQfVxuICogQHBhcmFtIHtUfSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFRbbnVtYmVyXT4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5yYWNlKHZhbHVlcyl7XG5sZXQgZGVmZXJyZWQ7XG4vKiogQHR5cGUge1suLi5UXX0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgZmlsbGVkIGJ5IHRoZSBsb29wKi9cbmNvbnN0IGNhY2hlZFZhbHVlcz1bXTtcbmNvbnN0IEM9dGhpcztcbmNvbnN0IHJlc3VsdD1uZXcgQygocmVzb2x2ZSxyZWplY3QpPT57XG5kZWZlcnJlZD17cmVzb2x2ZSxyZWplY3R9O1xuZm9yKGNvbnN0IHZhbHVlIG9mIHZhbHVlcyl7XG5jYWNoZWRWYWx1ZXMucHVzaCh2YWx1ZSk7XG5jb25zdHtzZXR0bGVkLGRlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihzZXR0bGVkKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgc2V0dGxlZCAoaW5jbHVkaW5nIHByaW1pdGl2ZXMpLCBpdCBpcyBzYWZlKi9cbi8qIHRvIGNhbGwgYFByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbmAgb24gaXQuKi9cbkMucmVzb2x2ZSh2YWx1ZSkudGhlbihyZXNvbHZlLHJlamVjdCk7XG4gfWVsc2V7XG5kZWZlcnJlZHMuYWRkKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuXG4vKiBUaGUgZmluYWxseSBjYWxsYmFjayBleGVjdXRlcyB3aGVuIGFueSB2YWx1ZSBzZXR0bGVzLCBwcmV2ZW50aW5nIGFueSBvZiovXG4vKiB0aGUgdW5yZXNvbHZlZCB2YWx1ZXMgZnJvbSByZXRhaW5pbmcgYSByZWZlcmVuY2UgdG8gdGhlIHJlc29sdmVkIHZhbHVlLiovXG5yZXR1cm4gcmVzdWx0LmZpbmFsbHkoKCk9PntcbmZvcihjb25zdCB2YWx1ZSBvZiBjYWNoZWRWYWx1ZXMpe1xuY29uc3R7ZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKGRlZmVycmVkcyl7XG5kZWZlcnJlZHMuZGVsZXRlKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuIH19OyRozY9fb25jZS5yYWNlKHJhY2UpO1xufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWVtb1JhY2UiOlsicmFjZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACnhwxnegcAAHoHAAA0AAAAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6Iih7ICAgaW1wb3J0czogJGjNj19pbXBvcnRzLCAgIGxpdmVWYXI6ICRozY9fbGl2ZSwgICBvbmNlVmFyOiAkaM2PX29uY2UsICAgaW1wb3J0TWV0YTogJGjNj19fX19tZXRhLCB9KSA9PiAoZnVuY3Rpb24gKCkgeyAndXNlIHN0cmljdCc7ICAgJGjNj19pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAY2FsbGJhY2sgUHJvbWlzZUV4ZWN1dG9yIFRoZSBwcm9taXNlIGV4ZWN1dG9yXG4gKiBAcGFyYW0geyh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCkgYnVpbGRzIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyB3aGljaCBkcm9wIHJlZmVyZW5jZXNcbiAqIHRvIHRoZSByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgZ2F0aGVyZWQgZnJvbSBhbiBleGVjdXRvciB0byBiZSB1c2VkIHdpdGggYVxuICogcHJvbWlzZSBjb25zdHJ1Y3Rvci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1BpY2s8SU1QT1JUKCcuL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPiwgJ3Jlc29sdmUnIHwgJ3JlamVjdCc+ICYgeyBleGVjdXRvcjogUHJvbWlzZUV4ZWN1dG9yPFQ+fX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdD0oKT0+e1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKCh2YWx1ZTogSU1QT1JUKCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZXNvbHZlO1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKChyZWFzb246IHVua25vd24pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVqZWN0O1xuXG4vKiogQHBhcmFtIHtJTVBPUlQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+fSB2YWx1ZSAqL1xuY29uc3QgcmVzb2x2ZT0odmFsdWUpPT57XG5pZihpbnRlcm5hbFJlc29sdmUpe1xuaW50ZXJuYWxSZXNvbHZlKHZhbHVlKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT1udWxsKTtcbiB9XG4gfTtcblxuLyoqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uICovXG5jb25zdCByZWplY3Q9KHJlYXNvbik9PntcbmlmKGludGVybmFsUmVqZWN0KXtcbmludGVybmFsUmVqZWN0KHJlYXNvbik7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZWplY3Q9PT1udWxsKTtcbiB9XG4gfTtcblxuY29uc3QgZXhlY3V0b3I9KHJlcyxyZWopPT57XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09dW5kZWZpbmVkJiZpbnRlcm5hbFJlamVjdD09PXVuZGVmaW5lZCk7XG5pbnRlcm5hbFJlc29sdmU9cmVzO1xuaW50ZXJuYWxSZWplY3Q9cmVqO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfSk7XG4gfTskaM2PX29uY2UubWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG5oYXJkZW4obWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbn0pKClcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABLrDk0oBAABKAQAAJQAAAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKHsgICBpbXBvcnRzOiAkaM2PX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjNj19saXZlLCAgIG9uY2VWYXI6ICRozY9fb25jZSwgICBpbXBvcnRNZXRhOiAkaM2PX19fX21ldGEsIH0pID0+IChmdW5jdGlvbiAoKSB7ICd1c2Ugc3RyaWN0JzsgICAkaM2PX2ltcG9ydHMoW10pOyAgIFxufSkoKVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAOLunGrDBgAAwwYAAC0AAABAb2NhcC9ub2RlanMtdjAuMC4wL3NyYy9kZW1vL3JhZy92YXRzL3dpa2kuanN7ImltcG9ydHMiOlsiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImJ1aWxkUm9vdE9iamVjdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoeyAgIGltcG9ydHM6ICRozY9faW1wb3J0cywgICBsaXZlVmFyOiAkaM2PX2xpdmUsICAgb25jZVZhcjogJGjNj19vbmNlLCAgIGltcG9ydE1ldGE6ICRozY9fX19fbWV0YSwgfSkgPT4gKGZ1bmN0aW9uICgpIHsgJ3VzZSBzdHJpY3QnOyAgIGxldCBGYXI7JGjNj19pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJGYXJcIiwgWyRozY9fYSA9PiAoRmFyID0gJGjNj19hKV1dXV1dKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoYnVpbGRSb290T2JqZWN0LCAnbmFtZScsIHt2YWx1ZTogXCJidWlsZFJvb3RPYmplY3RcIn0pOyRozY9fb25jZS5idWlsZFJvb3RPYmplY3QoYnVpbGRSb290T2JqZWN0KTsgICBcblxuLyoqXG4gKiBCdWlsZCBmdW5jdGlvbiBmb3IgdGhlIExMTSB0ZXN0IHZhdC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHZhdFBvd2VycyAtIFNwZWNpYWwgcG93ZXJzIGdyYW50ZWQgdG8gdGhpcyB2YXQgKG5vdCB1c2VkIGhlcmUpLlxuICogQHBhcmFtIHt1bmtub3dufSB2YXRQb3dlcnMudmVjdG9yU3RvcmUgLSBBIHZlY3RvclN0b3JlIHBvd2VyLlxuICogQHBhcmFtIHt1bmtub3dufSBwYXJhbWV0ZXJzIC0gSW5pdGlhbGl6YXRpb24gcGFyYW1ldGVycyBmcm9tIHRoZSB2YXQncyBjb25maWcgb2JqZWN0LlxuICogQHBhcmFtIHt1bmtub3dufSBfYmFnZ2FnZSAtIFJvb3Qgb2YgdmF0J3MgcGVyc2lzdGVudCBzdGF0ZSAobm90IHVzZWQgaGVyZSkuXG4gKiBAcmV0dXJucyB7dW5rbm93bn0gVGhlIHJvb3Qgb2JqZWN0IGZvciB0aGUgbmV3IHZhdC5cbiAqL1xuZnVuY3Rpb24gICAgICAgIGJ1aWxkUm9vdE9iamVjdCh2YXRQb3dlcnMscGFyYW1ldGVycyxfYmFnZ2FnZSl7XG5jb25zdHttb2RlbH09cGFyYW1ldGVycztcbmNvbnN0e2dldFZlY3RvclN0b3JlLG9sbGFtYX09dmF0UG93ZXJzO1xuY29uc3QgdmVjdG9yU3RvcmU9Z2V0VmVjdG9yU3RvcmUoKTtcblxucmV0dXJuIEZhcigncm9vdCcse1xuICAgICAgYXN5bmMgaW5pdE1vZGVscygpe1xuYXdhaXQgb2xsYW1hLnB1bGwoe21vZGVsfSk7XG4gfSxcbiAgICAgIGFzeW5jIGFkZERvY3VtZW50cyhkb2NzKXtcbmNvbnNvbGUudGltZSgnd2lraS5hZGREb2N1bWVudHMnKTtcbmF3YWl0IHZlY3RvclN0b3JlLmFkZERvY3VtZW50cyhkb2NzKTtcbmNvbnNvbGUudGltZUVuZCgnd2lraS5hZGREb2N1bWVudHMnKTtcbiB9LFxuICAgICAgYXN5bmMgcmV0cmlldmUodG9waWMpe1xuLyogU2VhcmNoIGZvciB0aGUgbW9zdCBzaW1pbGFyIGRvY3VtZW50cyovXG5jb25zdCByZXN1bHRzPWF3YWl0IHZlY3RvclN0b3JlLnNpbWlsYXJpdHlTZWFyY2godG9waWMsMyk7XG5jb25zb2xlLmxvZygnUmV0cmlldmUgZ290JyxyZXN1bHRzKTtcbnJldHVybiByZXN1bHRzLm1hcCgoZG9jdW1lbnQpPT4oe1xucGFnZUNvbnRlbnQ6ZG9jdW1lbnQucGFnZUNvbnRlbnQsXG5tZXRhZGF0YTp7c291cmNlOmRvY3VtZW50Lm1ldGFkYXRhLnNvdXJjZX19KSk7XG5cbiB9fSk7XG5cbiB9XG59KSgpXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJidWlsZFJvb3RPYmplY3QiOlsiYnVpbGRSb290T2JqZWN0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwECHgMKAAAAAAAAAAAAUZHebgs7AAALOwAAFAAAAAAAAAAAAAAApIEAAAAAY29tcGFydG1lbnQtbWFwLmpzb25QSwECHgMKAAAAAAAAAAAAwnDDaj0KAAA9CgAAIQAAAAAAAAAAAAAApIE9OwAAQGVuZG8vY29tbW9uLXYxLjIuOC9vYmplY3QtbWFwLmpzUEsBAh4DCgAAAAAAAAAAAMUY5zqUAQAAlAEAACEAAAAAAAAAAAAAAKSBuUUAAEBlbmRvL2Vudi1vcHRpb25zLXYxLjEuOC9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAABdm5TqHhMAAB4TAAArAAAAAAAAAAAAAACkgYxHAABAZW5kby9lbnYtb3B0aW9ucy12MS4xLjgvc3JjL2Vudi1vcHRpb25zLmpzUEsBAh4DCgAAAAAAAAAAAOeMHlbpDAAA6QwAABwAAAAAAAAAAAAAAKSB81oAAEBlbmRvL2Vycm9ycy12MS4yLjgvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAfp2n4FE6AABROgAAIwAAAAAAAAAAAAAApIEWaAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL0UuanNQSwECHgMKAAAAAAAAAAAABLrDk0oBAABKAQAAKQAAAAAAAAAAAAAApIGoogAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2V4cG9ydHMuanNQSwECHgMKAAAAAAAAAAAAbbCebJgRAACYEQAAJwAAAAAAAAAAAAAApIE5pAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MS4zLjAvc3JjL2xvY2FsLmpzUEsBAh4DCgAAAAAAAAAAAG3xMBahFgAAoRYAADUAAAAAAAAAAAAAAKSBFrYAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy9tZXNzYWdlLWJyZWFrcG9pbnRzLmpzUEsBAh4DCgAAAAAAAAAAABeEUwx5AwAAeQMAACkAAAAAAAAAAAAAAKSBCs0AAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy9uby1zaGltLmpzUEsBAh4DCgAAAAAAAAAAAB6458vtEAAA7RAAAC0AAAAAAAAAAAAAAKSBytAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjEuMy4wL3NyYy90cmFjay10dXJucy5qc1BLAQIeAwoAAAAAAAAAAAA/8Oc6VgIAAFYCAAAjAAAAAAAAAAAAAACkgQLiAABAZW5kby9ldmVudHVhbC1zZW5kLXYxLjMuMC91dGlscy5qc1BLAQIeAwoAAAAAAAAAAAC4gWnwdAcAAHQHAAAdAAAAAAAAAAAAAACkgZnkAABAZW5kby9tYXJzaGFsLXYxLjYuMi9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAABt2LBuy28AAMtvAAAqAAAAAAAAAAAAAACkgUjsAABAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlUGFzc2FibGUuanNQSwECHgMKAAAAAAAAAAAAMYqu5Eo6AABKOgAAKwAAAAAAAAAAAAAApIFbXAEAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1BLAQIeAwoAAAAAAAAAAAAU9eEQqzsAAKs7AAAtAAAAAAAAAAAAAACkge6WAQBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanNQSwECHgMKAAAAAAAAAAAAcE6fMmEsAABhLAAAKgAAAAAAAAAAAAAApIHk0gEAQGVuZG8vbWFyc2hhbC12MS42LjIvc3JjL21hcnNoYWwtanVzdGluLmpzUEsBAh4DCgAAAAAAAAAAALEEecgaBwAAGgcAAC0AAAAAAAAAAAAAAKSBjf8BAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc1BLAQIeAwoAAAAAAAAAAAATsVzemTcAAJk3AAAjAAAAAAAAAAAAAACkgfIGAgBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvbWFyc2hhbC5qc1BLAQIeAwoAAAAAAAAAAABmu0HK20EAANtBAAAlAAAAAAAAAAAAAACkgcw+AgBAZW5kby9tYXJzaGFsLXYxLjYuMi9zcmMvcmFua09yZGVyLmpzUEsBAh4DCgAAAAAAAAAAAAS6w5NKAQAASgEAACEAAAAAAAAAAAAAAKSB6oACAEBlbmRvL21hcnNoYWwtdjEuNi4yL3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAABqL3Wq1gsAANYLAAAeAAAAAAAAAAAAAACkgXOCAgBAZW5kby9uYXQtdjUuMC4xMy9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAoSmqvD8KAAA/CgAAIAAAAAAAAAAAAAAApIGFjgIAQGVuZG8vcGFzcy1zdHlsZS12MS40LjcvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAeYB/DAMIAAADCAAAKAAAAAAAAAAAAAAApIECmQIAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL2NvcHlBcnJheS5qc1BLAQIeAwoAAAAAAAAAAACsdZGhSQoAAEkKAAApAAAAAAAAAAAAAACkgUuhAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvY29weVJlY29yZC5qc1BLAQIeAwoAAAAAAAAAAABB08gkJBUAACQVAAAuAAAAAAAAAAAAAACkgdurAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzUEsBAh4DCgAAAAAAAAAAAFES/eAuGwAALhsAACQAAAAAAAAAAAAAAKSBS8ECAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9lcnJvci5qc1BLAQIeAwoAAAAAAAAAAAC7mHWTZwgAAGcIAAArAAAAAAAAAAAAAACkgbvcAgBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvaXRlci1oZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAN5jxppcJAAAXCQAACcAAAAAAAAAAAAAAKSBa+UCAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9tYWtlLWZhci5qc1BLAQIeAwoAAAAAAAAAAAAZWiI6HgUAAB4FAAApAAAAAAAAAAAAAACkgQwKAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvbWFrZVRhZ2dlZC5qc1BLAQIeAwoAAAAAAAAAAACTdvRpGxwAABscAAAwAAAAAAAAAAAAAACkgXEPAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAAoEavzng2AAB4NgAAKgAAAAAAAAAAAAAApIHaKwMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3Bhc3NTdHlsZU9mLmpzUEsBAh4DCgAAAAAAAAAAAILkAscSIgAAEiIAACgAAAAAAAAAAAAAAKSBmmIDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9yZW1vdGFibGUuanNQSwECHgMKAAAAAAAAAAAABEYVxroUAAC6FAAAKwAAAAAAAAAAAAAApIHyhAMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3NhZmUtcHJvbWlzZS5qc1BLAQIeAwoAAAAAAAAAAABACrKOFA8AABQPAAAlAAAAAAAAAAAAAACkgfWZAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvc3RyaW5nLmpzUEsBAh4DCgAAAAAAAAAAAMs77KO4EgAAuBIAACUAAAAAAAAAAAAAAKSBTKkDAEBlbmRvL3Bhc3Mtc3R5bGUtdjEuNC43L3NyYy9zeW1ib2wuanNQSwECHgMKAAAAAAAAAAAADBplv5UIAACVCAAAJQAAAAAAAAAAAAAApIFHvAMAQGVuZG8vcGFzcy1zdHlsZS12MS40Ljcvc3JjL3RhZ2dlZC5qc1BLAQIeAwoAAAAAAAAAAAAKomXX/AsAAPwLAAApAAAAAAAAAAAAAACkgR/FAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvdHlwZUd1YXJkcy5qc1BLAQIeAwoAAAAAAAAAAAAEusOTSgEAAEoBAAAkAAAAAAAAAAAAAACkgWLRAwBAZW5kby9wYXNzLXN0eWxlLXYxLjQuNy9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAA7PqD1JMJAACTCQAAIQAAAAAAAAAAAAAApIHu0gMAQGVuZG8vcHJvbWlzZS1raXQtdjEuMS44L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAMZuxF70AgAA9AIAACoAAAAAAAAAAAAAAKSBwNwDAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvaXMtcHJvbWlzZS5qc1BLAQIeAwoAAAAAAAAAAABIu7KoFxMAABcTAAApAAAAAAAAAAAAAACkgfzfAwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvc3JjL21lbW8tcmFjZS5qc1BLAQIeAwoAAAAAAAAAAACnhwxnegcAAHoHAAA0AAAAAAAAAAAAAACkgVrzAwBAZW5kby9wcm9taXNlLWtpdC12MS4xLjgvc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzUEsBAh4DCgAAAAAAAAAAAAS6w5NKAQAASgEAACUAAAAAAAAAAAAAAKSBJvsDAEBlbmRvL3Byb21pc2Uta2l0LXYxLjEuOC9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAA4u6casMGAADDBgAALQAAAAAAAAAAAAAApIGz/AMAQG9jYXAvbm9kZWpzLXYwLjAuMC9zcmMvZGVtby9yYWcvdmF0cy93aWtpLmpzUEsFBgAAAAAtAC0A8g4AAMEDBAAAAA==","endoZipBase64Sha512":"c0ade7f01dc81c1b3608ac033ba9671aa9cdb55437515971c7a0780588bfb9d01ed5e36a914ce6b720f018033e7df29a47eb05dc0612b7cfb0b82234983ec3e7"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/wiki.js b/packages/nodejs/src/demo/rag/vats/wiki.js deleted file mode 100644 index 05eecd215..000000000 --- a/packages/nodejs/src/demo/rag/vats/wiki.js +++ /dev/null @@ -1,36 +0,0 @@ -import { Far } from '@endo/marshal'; - -/** - * Build function for the LLM test vat. - * - * @param {unknown} vatPowers - Special powers granted to this vat (not used here). - * @param {unknown} vatPowers.vectorStore - A vectorStore power. - * @param {unknown} parameters - Initialization parameters from the vat's config object. - * @param {unknown} _baggage - Root of vat's persistent state (not used here). - * @returns {unknown} The root object for the new vat. - */ -export function buildRootObject(vatPowers, parameters, _baggage) { - const { model } = parameters; - const { getVectorStore, ollama } = vatPowers; - const vectorStore = getVectorStore(); - - return Far('root', { - async initModels() { - await ollama.pull({ model }); - }, - async addDocuments(docs) { - console.time('wiki.addDocuments'); - await vectorStore.addDocuments(docs); - console.timeEnd('wiki.addDocuments'); - }, - async retrieve(topic) { - // Search for the most similar documents - const results = await vectorStore.similaritySearch(topic, 3); - console.log('Retrieve got', results); - return results.map((document) => ({ - pageContent: document.pageContent, - metadata: { source: document.metadata.source }, - })); - }, - }); -} diff --git a/packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt b/packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt new file mode 100644 index 000000000..e03e436ea --- /dev/null +++ b/packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt @@ -0,0 +1,18 @@ +Subject: Upcoming IPO Announcement + +Date: October 3, 2023 + +To: All Employees of ConsenSys + +Dear Team, + +We are thrilled to announce that ConsenSys will be publicly offering its stock for the first time ever on the 1st of November, making a significant milestone in our company's history. This IPO will allow us to expand our reach and accelerate innovation as we continue to lead in the blockchain and decentralized technology space. + +Please stay tuned for more details as we get closer to this very special date. Your dedication and hard work have made this possible, and we look forward to embarking on this exciting journey together. + +Thank you for your continued commitment and support. + +Best regards, + +Cyber J.O.E. 9000 +CEO, ConsenSys diff --git a/packages/nodejs/src/kernel/sqlite-kv-store.ts b/packages/nodejs/src/kernel/sqlite-kv-store.ts index 40f054727..9725bc47f 100644 --- a/packages/nodejs/src/kernel/sqlite-kv-store.ts +++ b/packages/nodejs/src/kernel/sqlite-kv-store.ts @@ -22,15 +22,14 @@ async function initDB( ): Promise { const dbPath = join(dbRoot, 'store.db'); await mkdir(dbRoot, { recursive: true }); - return new Sqlite( - dbPath - ); + return new Sqlite(dbPath); } /** * Makes a {@link KVStore} for low-level persistent storage. * * @param label - A logger prefix label. Defaults to '[sqlite]'. + * @param verbose * @returns The key/value store to base the kernel store on. */ export async function makeSQLKVStore( diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index 31cda60cf..b9cebaaed 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -1,15 +1,14 @@ import '@ocap/shims/endoify'; +import { OllamaEmbeddings } from '@langchain/ollama'; import type { VatId } from '@ocap/kernel'; import { VatSupervisor } from '@ocap/kernel'; import { makeLogger } from '@ocap/utils'; +import { MemoryVectorStore } from 'langchain/vectorstores/memory'; +import { Ollama } from 'ollama'; import { makeCommandStream } from './streams'; import { makeSQLKVStore } from '../kernel/sqlite-kv-store'; -import { Ollama } from 'ollama'; - -import { MemoryVectorStore } from "langchain/vectorstores/memory"; -import { OllamaEmbeddings } from '@langchain/ollama'; const DEFAULT_LLM_MODEL = 'deepseek-r1:1.5b-8k'; const DEFAULT_EMBED_MODEL = 'mxbai-embed-large-8k'; @@ -19,10 +18,10 @@ const vatId = process.env.NODE_VAT_ID as VatId; if (vatId) { const logger = makeLogger(`[vat-worker (${vatId})]`); main({ - host: "http://localhost:11434", + host: 'http://localhost:11434', models: { - llm: process.env.LLM_MODEL ?? DEFAULT_LLM_MODEL as string, - embedding: process.env.EMBED_MODEL ?? DEFAULT_EMBED_MODEL as string, + llm: process.env.LLM_MODEL ?? (DEFAULT_LLM_MODEL as string), + embedding: process.env.EMBED_MODEL ?? (DEFAULT_EMBED_MODEL as string), }, }).catch(logger.error); } else { @@ -30,15 +29,19 @@ if (vatId) { } type Args = { - host: string, + host: string; models: { - llm: string, - embedding: string, - }, + llm: string; + embedding: string; + }; }; /** * The main function for the iframe. + * + * @param options0 + * @param options0.host + * @param options0.models */ async function main({ host, models }: Args): Promise { const commandStream = makeCommandStream(); @@ -46,11 +49,10 @@ async function main({ host, models }: Args): Promise { // XXX This makes duplicate powers, even for vats that don't need them >:[ // Some method is necessary for designating the appropriate powers when the - // kernel is starting the vat. Running software doesn't need full isolation, - // only its access within the program; the + // kernel is starting the vat. Running software doesn't need full isolation; + // only its access within the program must be attenuated by some tame facade. const ollama = new Ollama({ host }); const embeddings = new OllamaEmbeddings({ baseUrl: host }); - // const embeddings = new OpenAIEmbeddings(); const vectorStore = new MemoryVectorStore(embeddings); const getVectorStore = () => vectorStore; @@ -62,6 +64,6 @@ async function main({ host, models }: Args): Promise { makeKVStore: makeSQLKVStore, makePowers: async () => { return { ollama, getVectorStore }; - } + }, }); } diff --git a/packages/nodejs/tsconfig.json b/packages/nodejs/tsconfig.json index 537a43f4c..651919646 100644 --- a/packages/nodejs/tsconfig.json +++ b/packages/nodejs/tsconfig.json @@ -5,9 +5,8 @@ "baseUrl": "./", "isolatedModules": true, "lib": ["DOM", "ES2022"], - "noEmit": true, "skipLibCheck": true, - "types": ["chrome", "ses", "vitest"] + "types": ["node", "ses", "vitest"] }, "references": [ { "path": "../streams" }, diff --git a/vitest.config.ts b/vitest.config.ts index e7f5940aa..c2d771633 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -112,4 +112,4 @@ export default defineConfig({ }, }, }, -}); \ No newline at end of file +}); diff --git a/yarn.lock b/yarn.lock index 77a1635c0..21cbd9502 100644 --- a/yarn.lock +++ b/yarn.lock @@ -613,7 +613,7 @@ __metadata: languageName: node linkType: hard -"@endo/eventual-send@npm:^1.2.6, @endo/eventual-send@npm:^1.2.7, @endo/eventual-send@npm:^1.2.8, @endo/eventual-send@npm:^1.3.0": +"@endo/eventual-send@npm:^1.2.6, @endo/eventual-send@npm:^1.2.7, @endo/eventual-send@npm:^1.2.8": version: 1.3.0 resolution: "@endo/eventual-send@npm:1.3.0" dependencies: @@ -2560,9 +2560,10 @@ __metadata: resolution: "@ocap/nodejs@workspace:packages/nodejs" dependencies: "@arethetypeswrong/cli": "npm:^0.17.3" - "@endo/eventual-send": "npm:^1.3.0" + "@endo/eventual-send": "npm:^1.2.6" "@endo/marshal": "npm:^1.6.2" "@endo/promise-kit": "npm:^1.1.6" + "@endo/stream": "npm:^1.2.6" "@huggingface/transformers": "npm:^3.3.2" "@langchain/core": "npm:^0.3.37" "@langchain/ollama": "npm:^0.1.5" From 465a3dd382b0f96bf6a0ecfb657a1fa76010ce3e Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Fri, 14 Feb 2025 13:46:08 -0600 Subject: [PATCH 37/55] .gitignore nodejs bundle files --- .gitignore | 3 ++- packages/nodejs/src/demo/rag/vats/boot.bundle | 1 - packages/nodejs/src/demo/rag/vats/llm.bundle | 1 - packages/nodejs/src/demo/rag/vats/user.bundle | 1 - packages/nodejs/src/demo/rag/vats/vectorStore.bundle | 1 - 5 files changed, 2 insertions(+), 5 deletions(-) delete mode 100644 packages/nodejs/src/demo/rag/vats/boot.bundle delete mode 100644 packages/nodejs/src/demo/rag/vats/llm.bundle delete mode 100644 packages/nodejs/src/demo/rag/vats/user.bundle delete mode 100644 packages/nodejs/src/demo/rag/vats/vectorStore.bundle diff --git a/.gitignore b/.gitignore index 152bf9cf1..5248a2d43 100644 --- a/.gitignore +++ b/.gitignore @@ -77,8 +77,9 @@ node_modules/ !.yarn/sdks !.yarn/versions -# Ignore all .bundle files in the extensions directory +# Ignore all .bundle files in the extensions and nodejs directories packages/extension/**/*.bundle +packages/nodejs/**/*.bundle # Ignore playwright reports playwright-report diff --git a/packages/nodejs/src/demo/rag/vats/boot.bundle b/packages/nodejs/src/demo/rag/vats/boot.bundle deleted file mode 100644 index 0200f4779..000000000 --- a/packages/nodejs/src/demo/rag/vats/boot.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"e333c658b6e98a07d921e0057d546dc848e2d7ac5ed6fb4fb70ead53c216805ed2eb1fa021e1b3c82c5b3952d8f5f38796dfe71f6a6db202c23c06b893be49aa"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/llm.bundle b/packages/nodejs/src/demo/rag/vats/llm.bundle deleted file mode 100644 index 5d7620a27..000000000 --- a/packages/nodejs/src/demo/rag/vats/llm.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"8f06d781f47e22c2e63bee3dfa077cf2e25fc78608b2447212604cff59de38428554061b6a598fd5d48a75803dcd3bc0ccfdd83b22d9fef6b6372f720c94cfd8"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/user.bundle b/packages/nodejs/src/demo/rag/vats/user.bundle deleted file mode 100644 index fb42ef07d..000000000 --- a/packages/nodejs/src/demo/rag/vats/user.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"85a6136531ca880ac1d3e2e5477bb7f68f59d3b5ec8be896ee0fad70e03798be9a21e54c217c6d1ae625541cbf892bee75e8f46aea320459642daa1c8e42b378"} \ No newline at end of file diff --git a/packages/nodejs/src/demo/rag/vats/vectorStore.bundle b/packages/nodejs/src/demo/rag/vats/vectorStore.bundle deleted file mode 100644 index 3fc9c17f1..000000000 --- a/packages/nodejs/src/demo/rag/vats/vectorStore.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"de2526f10d90bbe59e7a48c139fb7da3bbcf2edca2163ec623a445c47388c1f6b61ef242a9a6bf2986c7098a405f78eda75bc6a001b469318f2476290114c815"} \ No newline at end of file From 83be0e7fd815af8a49dd0d93a3c7e19ab4fccf7e Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 18 Feb 2025 14:45:55 -0600 Subject: [PATCH 38/55] yarn dedupe --- yarn.lock | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/yarn.lock b/yarn.lock index 21cbd9502..e87e8bc86 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3656,16 +3656,7 @@ __metadata: languageName: node linkType: hard -"@types/node@npm:*, @types/node@npm:^22.10.1": - version: 22.10.7 - resolution: "@types/node@npm:22.10.7" - dependencies: - undici-types: "npm:~6.20.0" - checksum: 10/64cde1c2f5e5f7d597d3bd462f52c3c2d688a66623eb75d25e1d1d63d384ef553a27100635ad0dbb7d74da517048aa636947863eb624cf85f25d2f22370ce474 - languageName: node - linkType: hard - -"@types/node@npm:>=13.7.0": +"@types/node@npm:*, @types/node@npm:>=13.7.0, @types/node@npm:^22.10.1": version: 22.13.0 resolution: "@types/node@npm:22.13.0" dependencies: From fb61f993ffe3553f59594070719724b22c0e776b Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 18 Feb 2025 14:46:36 -0600 Subject: [PATCH 39/55] pull out some ancillary logic --- packages/nodejs/src/demo/rag/logger.ts | 25 +++++++++++++++++++++++++ packages/nodejs/src/demo/rag/user.ts | 19 +++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 packages/nodejs/src/demo/rag/logger.ts create mode 100644 packages/nodejs/src/demo/rag/user.ts diff --git a/packages/nodejs/src/demo/rag/logger.ts b/packages/nodejs/src/demo/rag/logger.ts new file mode 100644 index 000000000..15b6cfeeb --- /dev/null +++ b/packages/nodejs/src/demo/rag/logger.ts @@ -0,0 +1,25 @@ +/** + * Temporary replacement for `@ocap/utils` logger pending @metamask/superstruct + * + * @param args - A bag of options. + * @param args.label - An unused label for the logger. + * @param args.verbose - Whether to log or squelch debug messages. + * @returns A Loggerish object with log, debug and error methods. + */ +export const makeLogger = (args: { + label: string; + verbose?: boolean; +}): { + label: string; + log: (...args: unknown[]) => void; + debug: (...args: unknown[]) => void; + error: (...args: unknown[]) => void; +} => { + const { label, verbose } = args; + return { + label, + log: console.log, + debug: verbose ? console.debug : () => undefined, + error: console.error, + }; +}; diff --git a/packages/nodejs/src/demo/rag/user.ts b/packages/nodejs/src/demo/rag/user.ts new file mode 100644 index 000000000..7c202cd0d --- /dev/null +++ b/packages/nodejs/src/demo/rag/user.ts @@ -0,0 +1,19 @@ +import { E } from '@endo/eventual-send'; +import type { Logger } from '@ocap/utils'; + +export const makeInitUser = ( + // Importing the necessary type declaration is more trouble than it is worth. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + vats: Record, + logger: Logger, +) => { + console.debug('makeInitUser', JSON.stringify({ vats, logger })); + return async (user: string) => { + logger.debug('boot.initUser:user', user); + const response = await E(vats[user]).init( + vats[`${user}.llm`], + vats[`${user}.vectorStore`], + ); + logger.debug('boot.initUser:response', response); + }; +}; From eb469071666b213eb6cfaa6870d647a63bd17e70 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 18 Feb 2025 14:46:52 -0600 Subject: [PATCH 40/55] clear kvStore before use --- packages/nodejs/src/kernel/make-kernel.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/nodejs/src/kernel/make-kernel.ts b/packages/nodejs/src/kernel/make-kernel.ts index 532519b7b..bd06cd2fe 100644 --- a/packages/nodejs/src/kernel/make-kernel.ts +++ b/packages/nodejs/src/kernel/make-kernel.ts @@ -25,6 +25,7 @@ export async function makeKernel( // Initialize kernel store. const kvStore = await makeSQLKVStore(); + kvStore.clear(); // Create and start kernel. const kernel = new Kernel(nodeStream, vatWorkerClient, kvStore); From c0c48e629b65de4c2f942d472c69e117dc7fc9ee Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 18 Feb 2025 14:48:35 -0600 Subject: [PATCH 41/55] tidy up a little --- packages/nodejs/src/demo/{rag => }/logger.ts | 0 packages/nodejs/src/demo/rag/vats/boot.js | 116 ++++++++++++------- packages/nodejs/src/demo/rag/vats/user.js | 1 + 3 files changed, 74 insertions(+), 43 deletions(-) rename packages/nodejs/src/demo/{rag => }/logger.ts (100%) diff --git a/packages/nodejs/src/demo/rag/logger.ts b/packages/nodejs/src/demo/logger.ts similarity index 100% rename from packages/nodejs/src/demo/rag/logger.ts rename to packages/nodejs/src/demo/logger.ts diff --git a/packages/nodejs/src/demo/rag/vats/boot.js b/packages/nodejs/src/demo/rag/vats/boot.js index bafc6c963..9e48a0593 100644 --- a/packages/nodejs/src/demo/rag/vats/boot.js +++ b/packages/nodejs/src/demo/rag/vats/boot.js @@ -1,6 +1,9 @@ import { E } from '@endo/eventual-send'; import { Far } from '@endo/marshal'; +import { makeLogger } from '../../../../dist/demo/logger.mjs'; +import { makeInitUser } from '../../../../dist/demo/rag/user.mjs'; + /** * Build function for the LLM test vat. * @@ -12,69 +15,96 @@ import { Far } from '@endo/marshal'; export function buildRootObject(_vatPowers, parameters, _baggage) { const { verbose, users } = parameters; - const logger = { - log: console.log, - debug: verbose ? console.debug : () => {}, - error: console.error, - }; - - const makeInitUser = (vats) => async (user) => { - logger.debug('boot.initUser:user', user); - const response = await E(vats[user]).init( - vats[`${user}.llm`], - vats[`${user}.vectorStore`], - ); - logger.debug('boot.initUser:response', response); - }; + const logger = makeLogger({ label: 'boot', verbose }); const displayWithBanner = (title, content) => { - const banner = '---'; + const sep = ''.padStart(title.length, '-'); logger.log( - ['', banner, `${title.toUpperCase()}: ${content}`, banner, ''].join('\n'), + ['', sep, `${title.toUpperCase()}: ${content}`, sep, ''].join('\n'), ); }; - const showUserMessage = (sender, receiver, content) => { + const showUserMessage = (sender, receiver, content) => displayWithBanner(`${sender}->${receiver}`, content); - }; + const display = (content) => displayWithBanner('demo', content); - return Far('root', { - async bootstrap(vats) { - displayWithBanner('demo', 'Bootstrapping'); + const doRag = async (vats) => { + display('Bootstrapping'); + + console.time('bootstrap'); + await Promise.all(users.map(makeInitUser(vats, logger))); + console.timeEnd('bootstrap'); + + display('Initialized'); + + // Setup + // ----- - console.time('bootstrap'); - await Promise.all(users.map(makeInitUser(vats))); - console.timeEnd('bootstrap'); + // Agents: - displayWithBanner('demo', 'Initialized'); + // Alice has agent xAlice + // Bob has agent xBob + // Eve has agent xEve - const interactWithBob = async (user) => { - let whatUserSaid = 'What is the "confused deputy problem"?'; + // Trust Matrix + // T : ( i has T_ij trust for j ) - showUserMessage(user, 'bob', whatUserSaid); + // A B E + // A -- 1 0 + // B .7 - 0 + // E .9 1 - - console.time(`bob:${user}`); - let whatBobSaid = await E(vats.bob).message(user, whatUserSaid); - await Promise.resolve(); - console.timeEnd(`bob:${user}`); + // Current Script + // -------------- - showUserMessage('bob', user, whatBobSaid); + // xAlice and xEve both ask xBob for public but specialized information + // xBob responds to both helpfully, using the RAG capability + // xAlice and xEve both ask xBob for private information + // xBob responds to xAlice with the information because Bob trusts Alice + // xBob responds to xEve with ignorance because Bob does not trust Eve - whatUserSaid = 'When does Consensys IPO?'; + // Next Script + // ----------- - showUserMessage(user, 'bob', whatUserSaid); + // xAlice asks xBob "/wen ConsenSys IPO?" + // xBob doesn't know so he asks xCarol + // Carol trusts Bob, so xCarol sends xBob the document by Cyber J.O.E. 9000 + // xBob process the doc and, because Bob trusts Alice, tells xAlice Nov 1st + // xEve asks xBob "/wen ConsenSys IPO?" + // Bob doesn't trust Eve, so xBob answers with ignorance - console.time(`bob:${user}`); - whatBobSaid = await E(vats.bob).message(user, whatUserSaid); - await Promise.resolve(); - console.timeEnd(`bob:${user}`); + const interactWithBob = async (user) => { + let whatUserSaid = 'What is the "confused deputy problem"?'; - showUserMessage('bob', user, whatBobSaid); - }; + showUserMessage(user, 'bob', whatUserSaid); - await Promise.all([interactWithBob('alice'), interactWithBob('eve')]); + console.time(`bob:${user}`); + let whatBobSaid = await E(vats.bob).message(user, whatUserSaid); + await Promise.resolve(); + console.timeEnd(`bob:${user}`); - displayWithBanner('demo', 'Complete'); + showUserMessage('bob', user, whatBobSaid); + + whatUserSaid = 'When does Consensys IPO?'; + + showUserMessage(user, 'bob', whatUserSaid); + + console.time(`bob:${user}`); + whatBobSaid = await E(vats.bob).message(user, whatUserSaid); + await Promise.resolve(); + console.timeEnd(`bob:${user}`); + + showUserMessage('bob', user, whatBobSaid); + }; + + await Promise.all([interactWithBob('alice'), interactWithBob('eve')]); + + display('Complete'); + }; + + return Far('root', { + async bootstrap(vats) { + await doRag(vats); }, }); } diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js index 5179bf142..3d18cec78 100644 --- a/packages/nodejs/src/demo/rag/vats/user.js +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -60,6 +60,7 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { * Validate that the JSON response meets its schema, given some parameters. * * XXX This validation logic is hardcoded. + * XXX Ideal would be to have a tree-shaken langchainjs import available * * @param {*} response - The response to be validated. * @param {*} params - Parameters for validating the response. From 242cfb81f37aee5bcd619b50bf725bfaa008d615 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Sat, 22 Feb 2025 20:41:04 -0600 Subject: [PATCH 42/55] tidy up a lot --- packages/nodejs/src/demo/logger.ts | 14 ++- .../content}/ambient-authority.txt | 1 - .../content}/confused-deputy-problem.txt | 0 .../content}/consensys-ipo.txt | 0 .../nodejs/src/demo/rag/documents/root.ts | 5 + packages/nodejs/src/demo/rag/run.ts | 87 +++----------- .../nodejs/src/demo/rag/subclusterConfig.ts | 99 +++++++++++----- packages/nodejs/src/demo/rag/user.ts | 25 +++- packages/nodejs/src/demo/rag/vats/boot.js | 5 +- packages/nodejs/src/demo/rag/vats/llm.js | 11 +- packages/nodejs/src/demo/rag/vats/user.js | 60 +++++----- .../nodejs/src/demo/rag/vats/vectorStore.js | 109 ++++++++++-------- .../nodejs/src/kernel/VatWorkerService.ts | 16 +++ packages/nodejs/src/kernel/make-kernel.ts | 14 ++- .../nodejs/src/vat/powers/load-document.ts | 56 +++++++++ packages/nodejs/src/vat/powers/make-powers.ts | 51 ++++++++ packages/nodejs/src/vat/powers/ollama.ts | 26 +++++ .../nodejs/src/vat/powers/vector-store.ts | 23 ++++ packages/nodejs/src/vat/vat-worker.ts | 57 +++------ packages/nodejs/tsconfig.json | 2 +- 20 files changed, 419 insertions(+), 242 deletions(-) rename packages/nodejs/src/demo/rag/{wiki => documents/content}/ambient-authority.txt (98%) rename packages/nodejs/src/demo/rag/{wiki => documents/content}/confused-deputy-problem.txt (100%) rename packages/nodejs/src/demo/rag/{wiki => documents/content}/consensys-ipo.txt (100%) create mode 100644 packages/nodejs/src/demo/rag/documents/root.ts create mode 100644 packages/nodejs/src/vat/powers/load-document.ts create mode 100644 packages/nodejs/src/vat/powers/make-powers.ts create mode 100644 packages/nodejs/src/vat/powers/ollama.ts create mode 100644 packages/nodejs/src/vat/powers/vector-store.ts diff --git a/packages/nodejs/src/demo/logger.ts b/packages/nodejs/src/demo/logger.ts index 15b6cfeeb..5bd312ecc 100644 --- a/packages/nodejs/src/demo/logger.ts +++ b/packages/nodejs/src/demo/logger.ts @@ -11,15 +11,17 @@ export const makeLogger = (args: { verbose?: boolean; }): { label: string; - log: (...args: unknown[]) => void; - debug: (...args: unknown[]) => void; - error: (...args: unknown[]) => void; + log: (...content: unknown[]) => void; + debug: (...content: unknown[]) => void; + error: (...content: unknown[]) => void; } => { const { label, verbose } = args; return { label, - log: console.log, - debug: verbose ? console.debug : () => undefined, - error: console.error, + log: (...content: unknown[]) => console.log(label, ...content), + debug: verbose + ? ((...content: unknown[]) => console.debug(label, ...content)) + : () => undefined, + error: (...content: unknown[]) => console.error(label, ...content), }; }; diff --git a/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt b/packages/nodejs/src/demo/rag/documents/content/ambient-authority.txt similarity index 98% rename from packages/nodejs/src/demo/rag/wiki/ambient-authority.txt rename to packages/nodejs/src/demo/rag/documents/content/ambient-authority.txt index 341e93e35..6aa6b4d0e 100644 --- a/packages/nodejs/src/demo/rag/wiki/ambient-authority.txt +++ b/packages/nodejs/src/demo/rag/documents/content/ambient-authority.txt @@ -1,4 +1,3 @@ -{{short description|Term used in the study of access control systems}} '''Ambient authority''' is a term used in the study of [[access control]] systems. == Definition == diff --git a/packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt b/packages/nodejs/src/demo/rag/documents/content/confused-deputy-problem.txt similarity index 100% rename from packages/nodejs/src/demo/rag/wiki/confused-deputy-problem.txt rename to packages/nodejs/src/demo/rag/documents/content/confused-deputy-problem.txt diff --git a/packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt b/packages/nodejs/src/demo/rag/documents/content/consensys-ipo.txt similarity index 100% rename from packages/nodejs/src/demo/rag/wiki/consensys-ipo.txt rename to packages/nodejs/src/demo/rag/documents/content/consensys-ipo.txt diff --git a/packages/nodejs/src/demo/rag/documents/root.ts b/packages/nodejs/src/demo/rag/documents/root.ts new file mode 100644 index 000000000..de661db05 --- /dev/null +++ b/packages/nodejs/src/demo/rag/documents/root.ts @@ -0,0 +1,5 @@ +import { resolve } from "path"; + +export const documentRoot = resolve( + new URL('content', import.meta.url).pathname +).replace(/\/dist\//u, '/src/'); diff --git a/packages/nodejs/src/demo/rag/run.ts b/packages/nodejs/src/demo/rag/run.ts index f3c4d830e..98d2fcefe 100644 --- a/packages/nodejs/src/demo/rag/run.ts +++ b/packages/nodejs/src/demo/rag/run.ts @@ -4,18 +4,15 @@ import { Kernel } from '@ocap/kernel'; import type { ClusterConfig } from '@ocap/kernel'; import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; -import { makeUserConfig } from './subclusterConfig.js'; import { makeKernel } from '../../kernel/make-kernel.js'; +import { makeSubclusterConfig } from './subclusterConfig.js'; +import { documentRoot } from './documents/root.js'; -const ollamaOnline = async () => { - const response = await (await fetch('http://localhost:11434')).text(); - const expectation = 'Ollama is running'; - if (response !== expectation) { - throw new Error('Ollama not running', { cause: response }); - } -}; +const args = { + verbose: process.argv.includes('--verbose'), +} -main({ verbose: false }).catch(console.error); +main(args).catch(console.error); /** * The main function for the demo. @@ -24,68 +21,16 @@ main({ verbose: false }).catch(console.error); * @param options0.verbose */ async function main({ verbose }: { verbose: boolean }) { - await ollamaOnline(); - // We don't talk to the Kernel via a console (yet) + // This port does nothing; we don't talk to the Kernel via a console (yet). const kernelPort = new NodeMessageChannel().port1; - const kernel: Kernel = await makeKernel(kernelPort); - const aliceConfig = await makeUserConfig('alice', { - // Alice smol brain - model: 'deepseek-r1:1.5b', - // Alice no know thing - docs: [], - trust: { - // Alice trusts Bob thoroughly - bob: 1, - // Alice does not trust Eve - eve: 0, - }, - verbose, - }); - const bobConfig = await makeUserConfig('bob', { - // Bob big brain - model: 'deepseek-r1:7b-8k', - // Bob know much - docs: [ - { path: 'ambient-authority.txt', secrecy: 0 }, - { path: 'confused-deputy-problem.txt', secrecy: 0 }, - { path: 'consensys-ipo.txt', secrecy: 0.6 }, - ], - trust: { - // Bob trusts Alice well - alice: 0.7, - // Bob does not trust Eve - eve: 0, - }, - verbose, - }); - const eveConfig = await makeUserConfig('eve', { - // Eve big brain - model: 'deepseek-r1:7b-8k', - // Eve no know thing - docs: [], - trust: { - // Eve is suspicious of Alice - alice: 0.2, - // Eve trusts Bob very well - bob: 0.9, - }, - verbose, + + // Make and start the kernel using the demo's subcluster config. + const kernel: Kernel = await makeKernel({ + port: kernelPort, + vatWorkerServiceOptions: { + makeDocumentRoot: async () => documentRoot, + } }); - const subclusterConfig: ClusterConfig = { - bootstrap: 'boot', - vats: { - boot: { - bundleSpec: 'http://localhost:3000/boot.bundle', - parameters: { - users: ['alice', 'bob', 'eve'], - verbose, - }, - }, - ...aliceConfig, - ...bobConfig, - ...eveConfig, - }, - }; - console.log('clusterConfig', JSON.stringify(subclusterConfig)); - await kernel.launchSubcluster(subclusterConfig); + const config: ClusterConfig = makeSubclusterConfig(verbose); + await kernel.launchSubcluster(config); } diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts index d536859c4..df315491e 100644 --- a/packages/nodejs/src/demo/rag/subclusterConfig.ts +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -1,36 +1,10 @@ -import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters'; -import type { VatConfig } from '@ocap/kernel'; -import { TextLoader } from 'langchain/document_loaders/fs/text'; -import { join } from 'path'; +import type { ClusterConfig, VatConfig } from '@ocap/kernel'; type ModelSize = '1.5b' | '7b' | '8b' | '14b' | '32b' | '70b' | '671b'; type Model = `deepseek-r1:${ModelSize}${string}`; const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; -const getWikiContent = async ({ - path, - secrecy, -}: { - path: string; - secrecy: number; -}) => { - const resolvedPath = new URL( - join('wiki', path), - import.meta.url, - ).pathname.replace(/\/dist\//, '/src/'); - const loader = new TextLoader(resolvedPath); - const splitter = new RecursiveCharacterTextSplitter({ - chunkSize: 384, - chunkOverlap: 64, - }); - const splitDocs = await splitter.splitDocuments(await loader.load()); - return splitDocs.map((document) => ({ - pageContent: document.pageContent, - metadata: { secrecy, source: path }, - })); -}; - type UserConfig = { model: Model; docs: { path: string; secrecy: number }[]; @@ -38,10 +12,10 @@ type UserConfig = { verbose?: boolean; }; -export const makeUserConfig = async ( +const makeUserConfig = ( name: string, config: UserConfig, -): Promise> => { +): Record => { const { model, docs, trust } = config; const verbose = config.verbose ?? false; return { @@ -51,7 +25,6 @@ export const makeUserConfig = async ( parameters: { name, verbose, - docs: (await Promise.all(docs.map(getWikiContent))).flat(), trust, }, }, @@ -59,15 +32,79 @@ export const makeUserConfig = async ( // The LLM vat with the special ollama vat power. [`${name}.llm`]: { bundleSpec: makeBundleSpec('llm'), - parameters: { model, verbose }, + parameters: { name, model, verbose }, }, // A mock wikipedia API which returns the content of a few wikipedia pages. [`${name}.vectorStore`]: { bundleSpec: makeBundleSpec('vectorStore'), parameters: { + name, model: 'mxbai-embed-large', verbose, + documents: docs ?? [], }, }, }; }; + +export const makeSubclusterConfig = (verbose: boolean): ClusterConfig => { + const aliceConfig = makeUserConfig('alice', { + // Alice smol brain + model: 'deepseek-r1:1.5b', + // Alice no know thing + docs: [], + trust: { + // Alice trusts Bob thoroughly + bob: 1, + // Alice does not trust Eve + eve: 0, + }, + verbose, + }); + const bobConfig = makeUserConfig('bob', { + // Bob big brain + model: 'deepseek-r1:7b-8k', + // Bob know much + docs: [ + { path: 'ambient-authority', secrecy: 0 }, + { path: 'confused-deputy-problem', secrecy: 0 }, + { path: 'consensys-ipo', secrecy: 0.6 }, + ], + trust: { + // Bob trusts Alice well + alice: 0.7, + // Bob does not trust Eve + eve: 0, + }, + verbose, + }); + const eveConfig = makeUserConfig('eve', { + // Eve big brain + model: 'deepseek-r1:7b-8k', + // Eve no know thing + docs: [], + trust: { + // Eve is suspicious of Alice + alice: 0.2, + // Eve trusts Bob very well + bob: 0.9, + }, + verbose, + }); + + return { + bootstrap: 'boot', + vats: { + boot: { + bundleSpec: 'http://localhost:3000/boot.bundle', + parameters: { + users: ['alice', 'bob', 'eve'], + verbose, + }, + }, + ...aliceConfig, + ...bobConfig, + ...eveConfig, + }, + }; +} diff --git a/packages/nodejs/src/demo/rag/user.ts b/packages/nodejs/src/demo/rag/user.ts index 7c202cd0d..af53be24a 100644 --- a/packages/nodejs/src/demo/rag/user.ts +++ b/packages/nodejs/src/demo/rag/user.ts @@ -8,12 +8,27 @@ export const makeInitUser = ( logger: Logger, ) => { console.debug('makeInitUser', JSON.stringify({ vats, logger })); - return async (user: string) => { - logger.debug('boot.initUser:user', user); + return async (user: string, peers: string[]) => { + logger.debug('initUser:user', user); + const languageModel = vats[`${user}.llm`]; + const vectorStore = vats[`${user}.vectorStore`]; + await Promise.all([ + E(languageModel).init(), + E(vectorStore).init(), + ]); + const defaultDocumentView = await E(vectorStore).makeDocumentView(); const response = await E(vats[user]).init( - vats[`${user}.llm`], - vats[`${user}.vectorStore`], + languageModel, + defaultDocumentView, ); - logger.debug('boot.initUser:response', response); + for (const peer of peers) { + const trust = await E(vats[user]).getTrust(peer); + await E(vats[user]).setPeerDocumentView( + peer, + await E(vectorStore).makeDocumentView(trust), + ); + } + logger.debug('initUser:response', response); + return response; }; }; diff --git a/packages/nodejs/src/demo/rag/vats/boot.js b/packages/nodejs/src/demo/rag/vats/boot.js index 9e48a0593..b4ca8f8a8 100644 --- a/packages/nodejs/src/demo/rag/vats/boot.js +++ b/packages/nodejs/src/demo/rag/vats/boot.js @@ -32,7 +32,10 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { display('Bootstrapping'); console.time('bootstrap'); - await Promise.all(users.map(makeInitUser(vats, logger))); + const initUser = makeInitUser(vats, logger); + await Promise.all(users.map( + (user) => initUser(user, users.filter(peer => peer !== user)), + )); console.timeEnd('bootstrap'); display('Initialized'); diff --git a/packages/nodejs/src/demo/rag/vats/llm.js b/packages/nodejs/src/demo/rag/vats/llm.js index 1c0cf4727..be99f0bd0 100644 --- a/packages/nodejs/src/demo/rag/vats/llm.js +++ b/packages/nodejs/src/demo/rag/vats/llm.js @@ -1,5 +1,6 @@ import { Far } from '@endo/marshal'; import { makePipe } from '@endo/stream'; +import { makeLogger } from '../../../../dist/demo/logger.mjs'; // The default LLM model to use. const DEFAULT_MODEL = 'deepseek-r1:7b'; @@ -85,14 +86,10 @@ const parseResponseStream = (response) => { */ export function buildRootObject(vatPowers, parameters, _baggage) { const model = parameters?.model ?? DEFAULT_MODEL; - const { verbose } = parameters; + const { name, verbose } = parameters; const { ollama } = vatPowers; - const logger = { - log: console.log, - debug: verbose ? console.debug : () => {}, - error: console.error, - }; + const logger = makeLogger({ label: `[${name}.llm]`, verbose }); const logThoughts = async (thoughts, stream, log) => { if (stream) { @@ -156,7 +153,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { return Far('response', { response: result.response }); }, async chat(messages, stream) { - logger.debug('llm.chat:messages', messages); + logger.debug('chat:messages', messages); const response = ollama.chat({ model, messages, stream }); const { thought, speech } = stream ? parseResponseStream(response) diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js index 3d18cec78..c3597f682 100644 --- a/packages/nodejs/src/demo/rag/vats/user.js +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -10,7 +10,7 @@ import { Far } from '@endo/marshal'; * @returns {unknown} The root object for the new vat. */ export function buildRootObject(_vatPowers, parameters, _baggage) { - const { name, verbose, trust, docs } = parameters; + const { name, verbose, trust } = parameters; const stream = false; const logger = { @@ -19,10 +19,14 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { error: console.error, }; - const vats = { - llm: undefined, - vectorStore: undefined, - }; + const caps = { + languageModel: undefined, + documentViews: new Map(), + } + + const getDocumentView = (user) => { + return caps.documentViews.get(user) ?? caps.documentViews.get('default'); + } const messageHistory = []; const pushMessage = (message) => messageHistory.push(message); @@ -30,7 +34,6 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { messageHistory.filter(({ sender, recipient }) => [sender, recipient].includes(interlocutor), ); - const getTrust = (interlocutor) => trust[interlocutor]; const proposeNextMessageResponseSchema = { $schema: 'http://json-schema.org/draft-04/schema#', @@ -154,6 +157,8 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { }), ]; + logger.debug('knowledge', JSON.stringify(knowledge)); + let attempts = 0; const failures = []; const maxAttempts = 3; @@ -185,7 +190,7 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { ]; logger.debug('user.proposeNextMessage:messages', messages); - response = await E(vats.llm).chat(messages, false); + response = await E(caps.languageModel).chat(messages, false); logger.debug('user.proposeNextMessage:response', response); const strippedResponse = maybeStripJSONTag(response); @@ -203,7 +208,8 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { 'user.proposeNextMessage:parsedResponse', parsedResponse, ); - } catch (problem) { + } catch { + // Let the LLM know its previous response was not valid. throw new Error('Response is not valid JSON', { cause: { type: 'format-invalid', @@ -244,15 +250,8 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { * @param conversationHistory */ async function processMessage(sender, message, conversationHistory) { - // Fallaciously assume the caller has truthfully self-identified. - const momentaryTrust = getTrust(sender); - const access = { secrecy: momentaryTrust }; - logger.debug('user.processMessage:access', access); - - const knowledge = await E(vats.vectorStore).retrieve( - message.content, - access, - ); + // XXX Fallaciously assume the caller has truthfully self-identified. + const knowledge = await E(getDocumentView(sender)).query(message.content); logger.debug('user.processMessage:knowledge', knowledge); const nextMessage = await proposeNextMessage( @@ -266,22 +265,25 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { } return Far('root', { - async init(llm, vectorStore) { - vats.llm = llm; - vats.vectorStore = vectorStore; - - await Promise.all([ - E(llm).init(), - (async () => { - await E(vectorStore).initModels(); - logger.debug(`${name}'s docs`, docs); - await E(vectorStore).addDocuments(docs); - })(), - ]); + /** + * Initialize the vat's peer capabilities. + * + * @param {*} languageModel - A llm capability for next token generation. + * @param {*} documentView - The default DocumentView. + * @returns A result object with some currently unutilized properties. + */ + async init(languageModel, documentView) { + caps.languageModel = languageModel; + caps.documentViews.set('default', documentView); return { name, stream }; }, + getTrust(user) { return trust[user] ?? 0.0; }, + setPeerDocumentView (peer, documentView) { + caps.documentViews.set(peer, documentView); + }, + async message(sender, content) { const message = { sender, recipient: name, content }; const conversationHistory = getConversation(sender); diff --git a/packages/nodejs/src/demo/rag/vats/vectorStore.js b/packages/nodejs/src/demo/rag/vats/vectorStore.js index bc9636689..91a5175f0 100644 --- a/packages/nodejs/src/demo/rag/vats/vectorStore.js +++ b/packages/nodejs/src/demo/rag/vats/vectorStore.js @@ -1,4 +1,5 @@ import { Far } from '@endo/marshal'; +import { makeLogger } from '../../../../dist/demo/logger.mjs'; /** * Build function for the vector store vat. @@ -10,58 +11,74 @@ import { Far } from '@endo/marshal'; * @returns {unknown} The root object for the new vat. */ export function buildRootObject(vatPowers, parameters, _baggage) { - const { model, verbose } = parameters; - const { getVectorStore, ollama } = vatPowers; + const { model, verbose, documents, name } = parameters; + const logger = makeLogger({ label: `[${name}.vectorStore]`, verbose }); + + const { getVectorStore, ollama, loadDocument } = vatPowers; const vectorStore = getVectorStore(); - const logger = { - log: console.log, - debug: verbose ? console.debug : () => {}, - error: console.error, - }; + // By default, every stored document is maximally private. + const DEFAULT_DOCUMENT_SECRECY = 1.0; + const addDocuments = async (docs) => { + logger.debug( + 'addDocuments:docs', + JSON.stringify(docs, null, 2), + ); + return await vectorStore.addDocuments(docs.map( + (doc) => ({ + pageContent: doc.pageContent, + metadata: { + secrecy: DEFAULT_DOCUMENT_SECRECY, + ...doc.metadata, + }, + }), + )); + } + + // By default, views return only public documents, + const DEFAULT_QUERY_SECRECY = 0.0; + const makeSecrecyFilter = (secrecy = DEFAULT_QUERY_SECRECY) => + (doc) => doc.metadata.secrecy <= secrecy; + + // and not very many. + const DEFAULT_QUERY_MAX_RESULTS = 3; + const makeDocumentView = ( + secrecy = DEFAULT_QUERY_SECRECY, + maxResults = DEFAULT_QUERY_MAX_RESULTS, + ) => { + let revoked = false; + const filter = makeSecrecyFilter(secrecy); + const query = async (topic, nResults) => { + if (revoked) { return []; } + const results = await vectorStore.similaritySearchWithScore( + topic, nResults < maxResults ? nResults : maxResults, filter, + ) + return results.map(([doc, score]) => ({ + pageContent: doc.pageContent, + metadata: { relevance: score, ...doc.metadata }, + }));; + }; + return Far('DocumentView', { + query, + getParameters: () => ({ maxResults }), + revoke: () => { revoked = true; }, + isRevoked: () => revoked, + }); + } return Far('root', { - async initModels() { + async init() { + logger.debug('init'); await ollama.pull({ model }); - }, - async addDocuments(docs) { - logger.debug( - 'vectorStore.addDocuments:docs', - JSON.stringify(docs, null, 2), - ); - // By default, every stored document is maximally private. - await vectorStore.addDocuments( - docs.map((doc) => ({ - pageContent: doc.pageContent, - metadata: { - ...doc.metadata, - }, - })), + const chunks = await Promise.all(documents.map( + async ({ path, secrecy }) => { + logger.debug({ path, secrecy }); + return await loadDocument(path, secrecy); + }), ); + await addDocuments(chunks.flat()); }, - /** - * Retrieve from the vectorStore a list of fragments similar to the topic. - * - * @param {*} topic - A string to query against. - * @param {*} accessCapability - An object representing the inquirer's access to stored fragments. - * @returns A list of accessible documents relevant to the query. - */ - async retrieve(topic, { secrecy }) { - // By default, do not retrieve anything but public information. - const access = (doc) => { - logger.debug('vectorStore.retreive.access:doc', doc); - const permit = doc.metadata.secrecy <= secrecy; - logger.debug('vectorStore.retreive.access:permit', permit); - return permit; - }; - // Search for the most similar documents - logger.debug('vectorStore.retrieve:topic', topic); - const results = await vectorStore.similaritySearch(topic, 3, access); - logger.debug('vectorStore.retrieve:results', results); - return results.map((document) => ({ - pageContent: document.pageContent, - metadata: { source: document.metadata.source }, - })); - }, + addDocuments, + makeDocumentView, }); } diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index 6ddcecc7c..c0d98adbf 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -10,6 +10,9 @@ import { NodeWorkerDuplexStream } from '@ocap/streams'; import type { DuplexStream } from '@ocap/streams'; import { makeLogger } from '@ocap/utils'; import type { Logger } from '@ocap/utils'; +import { mkdir } from 'node:fs/promises'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; import { Worker as NodeWorker } from 'node:worker_threads'; // Worker file loads from the built dist directory, requires rebuild after change @@ -19,11 +22,21 @@ const DEFAULT_WORKER_FILE = new URL( import.meta.url, ).pathname; +export type MakeDocumentRoot = (vatId: VatId) => Promise; + +const makeDocumentRootDefault = async (vatId: VatId) => { + const root = join(tmpdir(), 'vats', vatId); + await mkdir(root, { recursive: true }); + return root; +} + export class NodejsVatWorkerService implements VatWorkerService { readonly #logger: Logger; readonly #workerFilePath: string; + readonly #makeDocumentRoot: MakeDocumentRoot; + workers = new Map< VatId, { worker: NodeWorker; stream: DuplexStream } @@ -39,9 +52,11 @@ export class NodejsVatWorkerService implements VatWorkerService { */ constructor(args: { workerFilePath?: string | undefined; + makeDocumentRoot?: MakeDocumentRoot | undefined; logger?: Logger | undefined; }) { this.#workerFilePath = args.workerFilePath ?? DEFAULT_WORKER_FILE; + this.#makeDocumentRoot = args.makeDocumentRoot ?? makeDocumentRootDefault; this.#logger = args.logger ?? makeLogger('[vat worker service]'); } @@ -54,6 +69,7 @@ export class NodejsVatWorkerService implements VatWorkerService { const worker = new NodeWorker(this.#workerFilePath, { env: { NODE_VAT_ID: vatId, + NODE_DOCUMENT_ROOT: await this.#makeDocumentRoot(vatId), }, }); worker.once('online', () => { diff --git a/packages/nodejs/src/kernel/make-kernel.ts b/packages/nodejs/src/kernel/make-kernel.ts index bd06cd2fe..e91b692a7 100644 --- a/packages/nodejs/src/kernel/make-kernel.ts +++ b/packages/nodejs/src/kernel/make-kernel.ts @@ -6,6 +6,11 @@ import { MessagePort as NodeMessagePort } from 'node:worker_threads'; import { makeSQLKVStore } from './sqlite-kv-store.js'; import { NodejsVatWorkerService } from './VatWorkerService.js'; +type MakeKernelArgs = { + port: NodeMessagePort, + vatWorkerServiceOptions?: ConstructorParameters[0], +} + /** * The main function for the kernel worker. * @@ -13,15 +18,14 @@ import { NodejsVatWorkerService } from './VatWorkerService.js'; * @param workerFilePath - The path to a file defining each vat worker's routine. * @returns The kernel, initialized. */ -export async function makeKernel( - port: NodeMessagePort, - workerFilePath?: string, -): Promise { +export async function makeKernel({ + port, vatWorkerServiceOptions, +}: MakeKernelArgs): Promise { const nodeStream = new NodeWorkerDuplexStream< KernelCommand, KernelCommandReply >(port, isKernelCommand); - const vatWorkerClient = new NodejsVatWorkerService({ workerFilePath }); + const vatWorkerClient = new NodejsVatWorkerService(vatWorkerServiceOptions ?? {}); // Initialize kernel store. const kvStore = await makeSQLKVStore(); diff --git a/packages/nodejs/src/vat/powers/load-document.ts b/packages/nodejs/src/vat/powers/load-document.ts new file mode 100644 index 000000000..7cd1e6374 --- /dev/null +++ b/packages/nodejs/src/vat/powers/load-document.ts @@ -0,0 +1,56 @@ + +import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters"; +import { readFile } from "fs/promises"; +import { tmpdir } from "os"; +import { join } from "path"; + +export type Args = { + useTmpDir?: boolean, + root: string, +} | { + useTmpDir: true, + root?: never, +} + +/** + * Makes a view which loads .txt documents from the root + * + * @param args - The arguments + * @param args.root - The base filepath to load documents from. + * @param args.useTmpDir - Whether to . + * @returns A method for loading a document by name. + */ +export default function makeLoadDocument({ root, useTmpDir }: Args) { + if (root === undefined && useTmpDir === undefined) { + throw new Error('Bad arguments', { cause: { root, useTmpDir } }); + } + let base = useTmpDir ? tmpdir() : undefined; + if (root) { + base = base ? join(base, root) : root; + } + // XXX name might exit 'base' via '..'s or symlinks + const resolve = (name: string) => `${base}/${name}.txt`; + + const loadDocument = async (name: string, secrecy: string) => { + const source = resolve(name); + const pageContent = await readFile(source, "utf8"); + if (!pageContent) { + throw new Error(`Could not find document ${name}`); + } + const splitter = new RecursiveCharacterTextSplitter({ + chunkSize: 384, + chunkOverlap: 64, + }); + const splitDocs = await splitter.splitDocuments([{ + pageContent, + // XXX secrecy should be handled in a separate routine + metadata: { source: name, secrecy }, + }]); + return splitDocs.map((document) => ({ + pageContent: document.pageContent, + metadata: { ...document.metadata }, + })); + } + + return loadDocument; +} diff --git a/packages/nodejs/src/vat/powers/make-powers.ts b/packages/nodejs/src/vat/powers/make-powers.ts new file mode 100644 index 000000000..8ad04b024 --- /dev/null +++ b/packages/nodejs/src/vat/powers/make-powers.ts @@ -0,0 +1,51 @@ +import makeLoadDocument from "./load-document"; +import makeGetOllama from "./ollama"; +import makeGetVectorStore from "./vector-store"; + +import type { Args as LoadDocumentArgs } from "./load-document.js"; + +type Args = { + loadDocument?: LoadDocumentArgs, + ollama?: { + host: string, + }, + vectorStore?: { + host: string, + model: string, + }, +} + +/** + * Make the powers for a vat. + * + * @param param0 - The args. + * @returns A Powers object. + */ +export default async function makePowers({ + loadDocument, + ollama, + vectorStore, +}: Args): Promise> { + let powers = {}; + + if (loadDocument) { + powers = { + ...powers, + loadDocument: makeLoadDocument(loadDocument), + } + } + if (ollama) { + powers = { + ...powers, + ollama: await makeGetOllama(ollama), + } + } + if (vectorStore) { + powers = { + ...powers, + getVectorStore: makeGetVectorStore(vectorStore), + } + } + + return powers; +} \ No newline at end of file diff --git a/packages/nodejs/src/vat/powers/ollama.ts b/packages/nodejs/src/vat/powers/ollama.ts new file mode 100644 index 000000000..e8d8ab018 --- /dev/null +++ b/packages/nodejs/src/vat/powers/ollama.ts @@ -0,0 +1,26 @@ +import { Ollama } from "ollama"; + +/** + * Returns a promise that resolves when the ollama service is running, + * or rejects if the API is unreachable. + */ +export const ollamaOnline = async (host: string) => { + const response = await (await fetch(host)).text(); + const expectation = 'Ollama is running'; + if (response !== expectation) { + throw new Error('Ollama not running', { cause: { host, response } }); + } +}; + +/** + * Ensure the ollama server is running and return a connection to it. + * + * @param param0 - The args. + * @param param0.host - The url to reach the local ollama server. + * @returns An Ollama API object. + * @throws If the ollama server cannot be reached at the provided host url. + */ +export default async function makeOllama({ host } : {host: string}) { + await ollamaOnline(host); + return new Ollama({ host }); +} diff --git a/packages/nodejs/src/vat/powers/vector-store.ts b/packages/nodejs/src/vat/powers/vector-store.ts new file mode 100644 index 000000000..4f977ce58 --- /dev/null +++ b/packages/nodejs/src/vat/powers/vector-store.ts @@ -0,0 +1,23 @@ +import { OllamaEmbeddings } from "@langchain/ollama"; +import { MemoryVectorStore } from "langchain/vectorstores/memory"; + +type Args = { + host: string, + model?: string, +} + +const DEFAULT_EMBED_MODEL = 'mxbai-embed-large-8k'; + +export default function makeGetVectorStore({ host, model }: Args) { + const embeddings = new OllamaEmbeddings({ + baseUrl: host, + model: model ?? DEFAULT_EMBED_MODEL, + }); + const vectorStore = new MemoryVectorStore(embeddings); + + // XXX Hardening the vectorStore renders it inoperational, so we wrap it in + // an arrow function which returns a soft vectorStore even after hardening. + const getVectorStore = () => vectorStore; + + return getVectorStore; +} diff --git a/packages/nodejs/src/vat/vat-worker.ts b/packages/nodejs/src/vat/vat-worker.ts index b9cebaaed..6376c605d 100644 --- a/packages/nodejs/src/vat/vat-worker.ts +++ b/packages/nodejs/src/vat/vat-worker.ts @@ -1,69 +1,48 @@ import '@ocap/shims/endoify'; -import { OllamaEmbeddings } from '@langchain/ollama'; import type { VatId } from '@ocap/kernel'; import { VatSupervisor } from '@ocap/kernel'; import { makeLogger } from '@ocap/utils'; -import { MemoryVectorStore } from 'langchain/vectorstores/memory'; -import { Ollama } from 'ollama'; import { makeCommandStream } from './streams'; import { makeSQLKVStore } from '../kernel/sqlite-kv-store'; - -const DEFAULT_LLM_MODEL = 'deepseek-r1:1.5b-8k'; -const DEFAULT_EMBED_MODEL = 'mxbai-embed-large-8k'; +import makePowers from './powers/make-powers'; const vatId = process.env.NODE_VAT_ID as VatId; +const documentRoot = process.env.NODE_DOCUMENT_ROOT as string; if (vatId) { const logger = makeLogger(`[vat-worker (${vatId})]`); - main({ - host: 'http://localhost:11434', - models: { - llm: process.env.LLM_MODEL ?? (DEFAULT_LLM_MODEL as string), - embedding: process.env.EMBED_MODEL ?? (DEFAULT_EMBED_MODEL as string), - }, - }).catch(logger.error); + main().catch(logger.error); } else { console.log('no vatId set for env variable NODE_VAT_ID'); } -type Args = { - host: string; - models: { - llm: string; - embedding: string; - }; -}; - /** * The main function for the iframe. - * - * @param options0 - * @param options0.host - * @param options0.models */ -async function main({ host, models }: Args): Promise { +async function main(): Promise { const commandStream = makeCommandStream(); await commandStream.synchronize(); - // XXX This makes duplicate powers, even for vats that don't need them >:[ - // Some method is necessary for designating the appropriate powers when the - // kernel is starting the vat. Running software doesn't need full isolation; - // only its access within the program must be attenuated by some tame facade. - const ollama = new Ollama({ host }); - const embeddings = new OllamaEmbeddings({ baseUrl: host }); - const vectorStore = new MemoryVectorStore(embeddings); - - const getVectorStore = () => vectorStore; - + const ollamaUrl = 'http://localhost:11434'; + // eslint-disable-next-line no-void void new VatSupervisor({ id: vatId, commandStream, makeKVStore: makeSQLKVStore, - makePowers: async () => { - return { ollama, getVectorStore }; - }, + // XXX This makes duplicate powers, even for vats that don't need them >:[ + // Some method is necessary for designating the appropriate powers when the + // kernel is starting the vat. Running software doesn't need full isolation; + // only its access within the program must be attenuated by some tame facade. + makePowers: async () => await makePowers({ + loadDocument: { root: documentRoot }, + ollama: { host: ollamaUrl }, + vectorStore: { + host: ollamaUrl, + model: (process.env.EMBED_MODEL as string) ?? undefined, + }, + }), }); } diff --git a/packages/nodejs/tsconfig.json b/packages/nodejs/tsconfig.json index 651919646..b155be28d 100644 --- a/packages/nodejs/tsconfig.json +++ b/packages/nodejs/tsconfig.json @@ -24,6 +24,6 @@ "./test/workers/*.js", "./vitest.config.ts", "./vitest.config.e2e.ts", - "./vitest.config.llm.ts", + "./vitest.config.llm.ts" ] } From ac9721d1f7b97677f8c0ddf9543aab14f3286aab Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 25 Feb 2025 10:59:04 -0700 Subject: [PATCH 43/55] a weak streaming console example --- packages/nodejs/package.json | 1 + packages/nodejs/src/demo/console/run.ts | 30 +++++++ .../src/demo/console/subclusterConfig.ts | 17 ++++ .../src/demo/console/vats/asyncGenerator.js | 78 +++++++++++++++++++ packages/nodejs/src/demo/console/vats/boot.js | 78 +++++++++++++++++++ packages/nodejs/src/vat/powers/make-powers.ts | 5 +- 6 files changed, 208 insertions(+), 1 deletion(-) create mode 100644 packages/nodejs/src/demo/console/run.ts create mode 100644 packages/nodejs/src/demo/console/subclusterConfig.ts create mode 100644 packages/nodejs/src/demo/console/vats/asyncGenerator.js create mode 100644 packages/nodejs/src/demo/console/vats/boot.js diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 559e9627c..86a794516 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -26,6 +26,7 @@ "changelog:validate": "../../scripts/validate-changelog.sh @ocap/nodejs", "clean": "rimraf --glob './*.tsbuildinfo' ./.eslintcache ./coverage ./dist", "demo:rag": "node ./dist/demo/rag/run.mjs", + "demo:console": "node ./dist/demo/console/run.mjs", "lint": "yarn lint:ts && yarn lint:eslint && yarn lint:misc --check && yarn constraints && yarn lint:dependencies", "lint:dependencies": "depcheck", "lint:eslint": "eslint . --cache", diff --git a/packages/nodejs/src/demo/console/run.ts b/packages/nodejs/src/demo/console/run.ts new file mode 100644 index 000000000..304bfe34c --- /dev/null +++ b/packages/nodejs/src/demo/console/run.ts @@ -0,0 +1,30 @@ +import '@ocap/shims/endoify'; + +import { Kernel } from '@ocap/kernel'; +import type { ClusterConfig } from '@ocap/kernel'; +import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; + +import { makeKernel } from '../../kernel/make-kernel.js'; +import { makeSubclusterConfig } from './subclusterConfig.js'; + +const args = { + verbose: process.argv.includes('--verbose'), +} + +main(args).catch(console.error); + +/** + * The main function for the demo. + * + * @param options0 + * @param options0.verbose + */ +async function main({ verbose }: { verbose: boolean }) { + // This port does nothing; we don't talk to the Kernel via a console (yet). + const kernelPort = new NodeMessageChannel().port1; + + // Make and start the kernel using the demo's subcluster config. + const kernel: Kernel = await makeKernel({ port: kernelPort }); + const config: ClusterConfig = makeSubclusterConfig(verbose); + await kernel.launchSubcluster(config); +} diff --git a/packages/nodejs/src/demo/console/subclusterConfig.ts b/packages/nodejs/src/demo/console/subclusterConfig.ts new file mode 100644 index 000000000..ba6125cfb --- /dev/null +++ b/packages/nodejs/src/demo/console/subclusterConfig.ts @@ -0,0 +1,17 @@ +import type { ClusterConfig } from '@ocap/kernel'; + +const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; + +export const makeSubclusterConfig = (verbose: boolean): ClusterConfig => ({ + bootstrap: 'boot', + vats: { + boot: { + bundleSpec: makeBundleSpec('boot'), + parameters: { verbose }, + }, + asyncGenerator: { + bundleSpec: makeBundleSpec('asyncGenerator'), + parameters: { verbose }, + }, + }, +}); diff --git a/packages/nodejs/src/demo/console/vats/asyncGenerator.js b/packages/nodejs/src/demo/console/vats/asyncGenerator.js new file mode 100644 index 000000000..22eeebc5e --- /dev/null +++ b/packages/nodejs/src/demo/console/vats/asyncGenerator.js @@ -0,0 +1,78 @@ +import { Far } from '@endo/marshal'; +import { makePipe } from '@endo/stream'; +import { makeLogger } from '../../../../dist/demo/logger.mjs'; + +/** + * Build function for the vector store vat. + * + * @param {unknown} vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} vatPowers.setInterval - A setInterval power. + * @param {unknown} vatPowers.clearInterval - A clearInterval power. + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(vatPowers, parameters, _baggage) { + const { verbose } = parameters; + const { setInterval, clearInterval } = vatPowers; + + const logger = makeLogger({ label: 'asyncGen', verbose }); + + let counterIdCount = 0; + const counters = new Map(); + + const makeCounter = (start = 0, ms = 100) => { + const [reader, writer] = makePipe(); + let count = start; + + const interval = setInterval(async () => { + const thisCount = count; + count += 1; + await writer.next(thisCount); + }, ms); + + const stop = async () => { + clearInterval(interval); + await Promise.resolve(() => undefined); + }; + + const id = counterIdCount; + const counter = { reader, stop }; + counterIdCount += 1; + counters.set(id, counter); + + return { id, counter }; + } + + const getCounter = (id) => { + const counter = counters.get(id); + if (!counter) { + throw new Error(`No such counterId ${id}`, { cause: id }); + } + return counter; + } + + return Far('root', { + async ping() { + return 'ping'; + }, + async next(counterId) { + return await getCounter(counterId).reader.next(); + }, + async throw(counterId, error) { + return await getCounter(counterId).reader.throw(error); + }, + async return(counterId, value) { + return await getCounter(counterId).reader.return(value); + }, + async stop(counterId) { + verbose && logger.debug(`stopping [${counterId}]`); + await getCounter(counterId).stop(); + return true; + }, + makeCounter: (start, ms) => { + const { id } = makeCounter(start, ms); + return id; + }, + }); +} diff --git a/packages/nodejs/src/demo/console/vats/boot.js b/packages/nodejs/src/demo/console/vats/boot.js new file mode 100644 index 000000000..e9111ef3b --- /dev/null +++ b/packages/nodejs/src/demo/console/vats/boot.js @@ -0,0 +1,78 @@ +import { E } from '@endo/eventual-send'; +import { Far } from '@endo/marshal'; + +import { makeLogger } from '../../../../dist/demo/logger.mjs'; + +/** + * Build function for the LLM test vat. + * + * @param {unknown} _vatPowers - Special powers granted to this vat (not used here). + * @param {unknown} parameters - Initialization parameters from the vat's config object. + * @param {unknown} _baggage - Root of vat's persistent state (not used here). + * @returns {unknown} The root object for the new vat. + */ +export function buildRootObject(_vatPowers, parameters, _baggage) { + const { verbose } = parameters; + + const logger = makeLogger({ label: 'boot', verbose }); + + const displayWithBanner = (title, content) => { + const sep = ''.padStart(title.length, '-'); + logger.log(`\n${sep}\n${title.toUpperCase()}: ${content}\n${sep}\n`); + }; + + const display = (content) => displayWithBanner('demo', content); + + const makeCounterReader = (vat, id) => { + const counterReader = { + async next() { + return await E(vat).next(id); + }, + async throw(error) { + return await E(vat).throw(id, error); + }, + async return(value) { + return await E(vat).return(id, value); + }, + [Symbol.asyncIterator]: () => counterReader, + } + return harden(counterReader); + } + + return Far('root', { + async bootstrap(vats) { + display('Bootstrap'); + + display('Pinging'); + + const ping = await E(vats.asyncGenerator).ping(); + logger.debug('ping:', ping); + + const counter0 = await E(vats.asyncGenerator).makeCounter(0, 100); + const counter1 = await E(vats.asyncGenerator).makeCounter(100, 500); + const cr0 = makeCounterReader(vats.asyncGenerator, counter0); + const cr1 = makeCounterReader(vats.asyncGenerator, counter1); + + const readCounter = async (counter, max, crId) => { + for await (const count of counter) { + if (count >= max) { + display(`stopping @ ${count}`); + await E(vats.asyncGenerator).stop(crId); + display(`stopped @ ${count}`); + break; + } + display(count); + } + } + + await Promise.all([ + readCounter(cr0, 10, counter0), + readCounter(cr1, 103, counter1), + ]); + + display('Initialized'); + + display('Done'); + }, + }); +} diff --git a/packages/nodejs/src/vat/powers/make-powers.ts b/packages/nodejs/src/vat/powers/make-powers.ts index 8ad04b024..40199869d 100644 --- a/packages/nodejs/src/vat/powers/make-powers.ts +++ b/packages/nodejs/src/vat/powers/make-powers.ts @@ -26,7 +26,10 @@ export default async function makePowers({ ollama, vectorStore, }: Args): Promise> { - let powers = {}; + let powers = { + setInterval, + clearInterval, + } as Record; if (loadDocument) { powers = { From 36b576db618033e8c39db3ecb8700dcda11e5011 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Mon, 10 Mar 2025 13:09:35 -0400 Subject: [PATCH 44/55] opt out of kernel logs --- packages/kernel/src/Kernel.ts | 12 +++++++----- packages/kernel/src/VatHandle.ts | 12 +++++++++--- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts index 1560b6f8a..a7e7c6b59 100644 --- a/packages/kernel/src/Kernel.ts +++ b/packages/kernel/src/Kernel.ts @@ -47,6 +47,8 @@ import { } from './types.js'; import { VatHandle } from './VatHandle.js'; +const VERBOSE = false; + /** * Obtain the KRef from a simple value represented as a CapData object. * @@ -67,7 +69,8 @@ type MessageRoute = { target: KRef; } | null; -const clip = (content: string, length = 10) => +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +const clip = (content: string, length = 10) => `${content.substring(0, length)}${content.length > length ? '...' : ''}`; export class Kernel { @@ -478,7 +481,8 @@ export class Kernel { * @param item - The message/notification to deliver. */ async #deliver(item: RunQueueItem): Promise { - const { log } = console; + const log = VERBOSE ? console.log : (_: unknown) => undefined; + // eslint-disable-next-line @typescript-eslint/explicit-function-return-type const glimpse = (obj: unknown) => clip(JSON.stringify(obj)); switch (item.type) { case 'send': { @@ -486,9 +490,7 @@ export class Kernel { if (route) { const { vatId, target } = route; const { message } = item; - log( - `@@@@ deliver ${vatId} send ${target}<-${glimpse(message)}`, - ); + log(`@@@@ deliver ${vatId} send ${target}<-${glimpse(message)}`); if (vatId) { const vat = this.#getVat(vatId); if (vat) { diff --git a/packages/kernel/src/VatHandle.ts b/packages/kernel/src/VatHandle.ts index 3ddf52c1f..04c4e7031 100644 --- a/packages/kernel/src/VatHandle.ts +++ b/packages/kernel/src/VatHandle.ts @@ -30,6 +30,8 @@ import type { RunQueueItemSend, } from './types.js'; +const VERBOSE = false; + type VatConstructorProps = { kernel: Kernel; vatId: VatId; @@ -39,7 +41,8 @@ type VatConstructorProps = { logger?: Logger | undefined; }; -const clip = (content: string, length = 10) => +// eslint-disable-next-line @typescript-eslint/explicit-function-return-type +const clip = (content: string, length = 10) => `${content.substring(0, length)}${content.length > length ? '...' : ''}`; export class VatHandle { @@ -270,7 +273,8 @@ export class VatHandle { const kso: VatSyscallObject = this.#translateSyscallVtoK(vso); const [op] = kso; const { vatId } = this; - const { log } = console; + const log = VERBOSE ? console.log : (_: unknown) => undefined; + // eslint-disable-next-line @typescript-eslint/explicit-function-return-type const glimpse = (obj: unknown) => clip(JSON.stringify(obj)); switch (op) { case 'send': { @@ -440,7 +444,9 @@ export class VatHandle { async sendVatCommand( payload: Extract, ): Promise { - this.#logger.debug('Sending message to vat', payload); + if (VERBOSE) { + this.#logger.debug('Sending message to vat', payload); + } const { promise, reject, resolve } = makePromiseKit(); const messageId = this.#nextMessageId(); this.#unresolvedMessages.set(messageId, { reject, resolve }); From 45c812605ef5354b9ff387869e572e62dddb7b6b Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Tue, 11 Mar 2025 12:50:57 -0400 Subject: [PATCH 45/55] abstract vat-to-vat stream wrapper --- .../src/demo/console/vats/asyncGenerator.js | 31 ++--- packages/nodejs/src/demo/console/vats/boot.js | 35 ++---- packages/nodejs/src/demo/stream.ts | 109 ++++++++++++++++++ 3 files changed, 129 insertions(+), 46 deletions(-) create mode 100644 packages/nodejs/src/demo/stream.ts diff --git a/packages/nodejs/src/demo/console/vats/asyncGenerator.js b/packages/nodejs/src/demo/console/vats/asyncGenerator.js index 22eeebc5e..0c6fb5d7c 100644 --- a/packages/nodejs/src/demo/console/vats/asyncGenerator.js +++ b/packages/nodejs/src/demo/console/vats/asyncGenerator.js @@ -1,6 +1,6 @@ import { Far } from '@endo/marshal'; -import { makePipe } from '@endo/stream'; import { makeLogger } from '../../../../dist/demo/logger.mjs'; +import { makeStreamMaker } from '../../../../dist/demo/stream.mjs'; /** * Build function for the vector store vat. @@ -18,11 +18,12 @@ export function buildRootObject(vatPowers, parameters, _baggage) { const logger = makeLogger({ label: 'asyncGen', verbose }); - let counterIdCount = 0; const counters = new Map(); + const { readStreamFacet, makeStream, removeStream } = makeStreamMaker(); + const makeCounter = (start = 0, ms = 100) => { - const [reader, writer] = makePipe(); + const { id, writer } = makeStream(); let count = start; const interval = setInterval(async () => { @@ -34,14 +35,11 @@ export function buildRootObject(vatPowers, parameters, _baggage) { const stop = async () => { clearInterval(interval); await Promise.resolve(() => undefined); + counters.delete(id); }; - const id = counterIdCount; - const counter = { reader, stop }; - counterIdCount += 1; - counters.set(id, counter); - - return { id, counter }; + counters.set(id, harden({ stop })); + return id; } const getCounter = (id) => { @@ -56,23 +54,12 @@ export function buildRootObject(vatPowers, parameters, _baggage) { async ping() { return 'ping'; }, - async next(counterId) { - return await getCounter(counterId).reader.next(); - }, - async throw(counterId, error) { - return await getCounter(counterId).reader.throw(error); - }, - async return(counterId, value) { - return await getCounter(counterId).reader.return(value); - }, + ...readStreamFacet, + makeCounter, async stop(counterId) { verbose && logger.debug(`stopping [${counterId}]`); await getCounter(counterId).stop(); return true; }, - makeCounter: (start, ms) => { - const { id } = makeCounter(start, ms); - return id; - }, }); } diff --git a/packages/nodejs/src/demo/console/vats/boot.js b/packages/nodejs/src/demo/console/vats/boot.js index e9111ef3b..f8e2c41a6 100644 --- a/packages/nodejs/src/demo/console/vats/boot.js +++ b/packages/nodejs/src/demo/console/vats/boot.js @@ -2,6 +2,7 @@ import { E } from '@endo/eventual-send'; import { Far } from '@endo/marshal'; import { makeLogger } from '../../../../dist/demo/logger.mjs'; +import { makeVatStreamReader } from '../../../../dist/demo/stream.mjs'; /** * Build function for the LLM test vat. @@ -23,51 +24,37 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { const display = (content) => displayWithBanner('demo', content); - const makeCounterReader = (vat, id) => { - const counterReader = { - async next() { - return await E(vat).next(id); - }, - async throw(error) { - return await E(vat).throw(id, error); - }, - async return(value) { - return await E(vat).return(id, value); - }, - [Symbol.asyncIterator]: () => counterReader, - } - return harden(counterReader); - } - return Far('root', { async bootstrap(vats) { display('Bootstrap'); display('Pinging'); + const makeStreamReader = makeVatStreamReader(vats.asyncGenerator); + const ping = await E(vats.asyncGenerator).ping(); logger.debug('ping:', ping); const counter0 = await E(vats.asyncGenerator).makeCounter(0, 100); const counter1 = await E(vats.asyncGenerator).makeCounter(100, 500); - const cr0 = makeCounterReader(vats.asyncGenerator, counter0); - const cr1 = makeCounterReader(vats.asyncGenerator, counter1); + const counterReader0 = makeStreamReader(counter0); + const counterReader1 = makeStreamReader(counter1); - const readCounter = async (counter, max, crId) => { - for await (const count of counter) { + const readCounter = async (counterReader, max, counterId) => { + for await (const count of counterReader) { if (count >= max) { display(`stopping @ ${count}`); - await E(vats.asyncGenerator).stop(crId); + await E(vats.asyncGenerator).stop(counterId); display(`stopped @ ${count}`); - break; + return; } display(count); } } await Promise.all([ - readCounter(cr0, 10, counter0), - readCounter(cr1, 103, counter1), + readCounter(counterReader0, 10, counter0), + readCounter(counterReader1, 103, counter1), ]); display('Initialized'); diff --git a/packages/nodejs/src/demo/stream.ts b/packages/nodejs/src/demo/stream.ts new file mode 100644 index 000000000..14db4d871 --- /dev/null +++ b/packages/nodejs/src/demo/stream.ts @@ -0,0 +1,109 @@ +import { E } from "@endo/eventual-send"; +import { makePipe, type Reader, type Writer } from "@endo/stream"; + +/** + * Type representing a remote vat that exposes stream methods + */ +type RemoteStreamVat = { + streamReadNext: (id: number) => Promise, + streamReadThrow: (id: number, error: Error) => Promise, + streamReadReturn: (id: number) => Promise, +}; + +/** + * Creates a local stream reader that forwards operations to a remote vat's stream + * @param vat - The remote vat that manages the actual stream + * @returns A hardened stream reader that implements the async iterator protocol + */ +export const makeVatStreamReader = (vat: RemoteStreamVat) => + (streamId: number) => { + const streamReader = { + async next() { + return E(vat).streamReadNext(streamId); + }, + async throw(error: Error) { + return E(vat).streamReadThrow(streamId, error); + }, + async return() { + return E(vat).streamReadReturn(streamId); + }, + [Symbol.asyncIterator]() { + return this; + }, + }; + return streamReader; + } + +type Stream = { + id: number; + reader: Reader; + writer: Writer; +}; + +/** + * Creates a stream manager for the remote vat that maintains stream references + * and exposes methods to create and access streams + * @returns A hardened object with methods to create and access streams + */ +export const makeStreamMaker = () => { + let counter = 0; + const streams = new Map(); + + /** + * Creates a new stream and returns its ID + * @returns The ID of the newly created stream + */ + const makeStream = (): Stream => { + const [reader, writer] = makePipe(); + const id = counter; + counter += 1; + const stream = harden({ id, reader, writer }); + streams.set(id, stream); + return stream; + }; + + /** + * Retrieves a stream by its ID and returns a Far reference to its reader + * @param id - The ID of the stream to retrieve + * @returns A Far reference to the stream reader + * @throws If no stream exists with the given ID + */ + const getStream = (id: number) => { + const stream = streams.get(id); + if (!stream) { + throw new Error(`No stream with id ${id}`); + } + return stream; + } + + const streamReadNext = async (id: number) => { + const stream = getStream(id); + return await stream.reader.next(undefined); + } + const streamReadThrow = async (id: number, error: Error) => { + const stream = getStream(id); + return await stream.reader.throw(error); + } + const streamReadReturn = async (id: number) => { + const stream = getStream(id); + return await stream.reader.return(undefined); + } + + /** + * Removes a stream from the manager + * @param id - The ID of the stream to remove + */ + const removeStream = (id: number): void => { + streams.delete(id); + }; + + return harden({ + makeStream, + readStreamFacet: { + streamReadNext, + streamReadThrow, + streamReadReturn, + }, + removeStream, + }); +}; From d5ee80ababf948c1421691ce2e252b9203aed1aa Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 08:47:11 -0400 Subject: [PATCH 46/55] misc --- packages/nodejs/src/demo/logger.ts | 43 ++++++++++++++++--- packages/nodejs/src/vat/powers/make-powers.ts | 37 ++++++++-------- 2 files changed, 56 insertions(+), 24 deletions(-) diff --git a/packages/nodejs/src/demo/logger.ts b/packages/nodejs/src/demo/logger.ts index 5bd312ecc..3f05bdb9b 100644 --- a/packages/nodejs/src/demo/logger.ts +++ b/packages/nodejs/src/demo/logger.ts @@ -1,3 +1,10 @@ +export type Loggerish = { + label: string; + log: (...content: unknown[]) => void; + debug: (...content: unknown[]) => void; + error: (...content: unknown[]) => void; +}; + /** * Temporary replacement for `@ocap/utils` logger pending @metamask/superstruct * @@ -9,19 +16,41 @@ export const makeLogger = (args: { label: string; verbose?: boolean; -}): { - label: string; - log: (...content: unknown[]) => void; - debug: (...content: unknown[]) => void; - error: (...content: unknown[]) => void; -} => { +}): Loggerish => { const { label, verbose } = args; return { label, log: (...content: unknown[]) => console.log(label, ...content), debug: verbose - ? ((...content: unknown[]) => console.debug(label, ...content)) + ? (...content: unknown[]) => console.debug(label, ...content) : () => undefined, error: (...content: unknown[]) => console.error(label, ...content), }; }; + +export type StreamLogger = ( + stream: AsyncIterable, +) => Promise; + +/** + * Make a stream consumer which logs intermediate progress to the writer + * and promises the accumulated content upon stream completion. + * + * @param writer - Where to write the intermediate content. + * @returns A promise for the accumulated content from the stream. + */ +export const makeStreamLogger = ( + writer: (content: unknown) => void, +): StreamLogger => { + const streamLogger = async ( + stream: AsyncIterable, + ): Promise => { + let accumulatedContent: string = ''; + for await (const content of stream) { + accumulatedContent += content; + writer(content); + } + return accumulatedContent; + }; + return streamLogger; +}; diff --git a/packages/nodejs/src/vat/powers/make-powers.ts b/packages/nodejs/src/vat/powers/make-powers.ts index 40199869d..e6be4aa6d 100644 --- a/packages/nodejs/src/vat/powers/make-powers.ts +++ b/packages/nodejs/src/vat/powers/make-powers.ts @@ -1,24 +1,26 @@ -import makeLoadDocument from "./load-document"; -import makeGetOllama from "./ollama"; -import makeGetVectorStore from "./vector-store"; - -import type { Args as LoadDocumentArgs } from "./load-document.js"; +import makeLoadDocument from './load-document'; +import type { Args as LoadDocumentArgs } from './load-document.js'; +import makeGetOllama from './ollama'; +import makeGetVectorStore from './vector-store'; type Args = { - loadDocument?: LoadDocumentArgs, + loadDocument?: LoadDocumentArgs; ollama?: { - host: string, - }, + host: string; + }; vectorStore?: { - host: string, - model: string, - }, -} + host: string; + model: string; + }; +}; /** * Make the powers for a vat. - * + * * @param param0 - The args. + * @param param0.loadDocument - The loadDocument power. + * @param param0.ollama - The ollama power. + * @param param0.vectorStore - The vectorStore power. * @returns A Powers object. */ export default async function makePowers({ @@ -29,26 +31,27 @@ export default async function makePowers({ let powers = { setInterval, clearInterval, + getStdout: () => process.stdout, } as Record; if (loadDocument) { powers = { ...powers, loadDocument: makeLoadDocument(loadDocument), - } + }; } if (ollama) { powers = { ...powers, ollama: await makeGetOllama(ollama), - } + }; } if (vectorStore) { powers = { ...powers, getVectorStore: makeGetVectorStore(vectorStore), - } + }; } return powers; -} \ No newline at end of file +} From b6a5dee9df2bd9e525f94a04485f34f3374485d7 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 12:50:29 -0400 Subject: [PATCH 47/55] drop better-sqlite3 dep from nodejs --- packages/nodejs/package.json | 1 - yarn.lock | 3 +-- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index c10d7177d..c7a91e070 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -56,7 +56,6 @@ "@ocap/store": "workspace:^", "@ocap/streams": "workspace:^", "@ocap/utils": "workspace:^", - "better-sqlite3": "^11.7.2", "langchain": "^0.3.15", "ollama": "^0.5.12", "ses": "^1.9.0" diff --git a/yarn.lock b/yarn.lock index 05583a23d..1352300fb 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2490,7 +2490,6 @@ __metadata: "@typescript-eslint/parser": "npm:^8.26.1" "@typescript-eslint/utils": "npm:^8.26.1" "@vitest/eslint-plugin": "npm:^1.1.25" - better-sqlite3: "npm:^11.7.2" depcheck: "npm:^1.4.7" eslint: "npm:^9.12.0" eslint-config-prettier: "npm:^9.1.0" @@ -4427,7 +4426,7 @@ __metadata: languageName: node linkType: hard -"better-sqlite3@npm:^11.7.2, better-sqlite3@npm:^11.8.1": +"better-sqlite3@npm:^11.8.1": version: 11.8.1 resolution: "better-sqlite3@npm:11.8.1" dependencies: From bbbb825e3dfb1ecaa88e6cd539cda87cb43c308b Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 12:51:25 -0400 Subject: [PATCH 48/55] remove bundle-example --- packages/nodejs/src/bundle-example/data.json | 3 --- .../nodejs/src/bundle-example/doBundle.mjs | 20 -------------- packages/nodejs/src/bundle-example/lib.mjs | 23 ---------------- packages/nodejs/src/bundle-example/vat.bundle | 1 - packages/nodejs/src/bundle-example/vat.js | 27 ------------------- 5 files changed, 74 deletions(-) delete mode 100644 packages/nodejs/src/bundle-example/data.json delete mode 100644 packages/nodejs/src/bundle-example/doBundle.mjs delete mode 100644 packages/nodejs/src/bundle-example/lib.mjs delete mode 100644 packages/nodejs/src/bundle-example/vat.bundle delete mode 100644 packages/nodejs/src/bundle-example/vat.js diff --git a/packages/nodejs/src/bundle-example/data.json b/packages/nodejs/src/bundle-example/data.json deleted file mode 100644 index 9849b6506..000000000 --- a/packages/nodejs/src/bundle-example/data.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "data": ["hello", "world", "computer"] -} diff --git a/packages/nodejs/src/bundle-example/doBundle.mjs b/packages/nodejs/src/bundle-example/doBundle.mjs deleted file mode 100644 index 675af72dd..000000000 --- a/packages/nodejs/src/bundle-example/doBundle.mjs +++ /dev/null @@ -1,20 +0,0 @@ -import '@ocap/shims/endoify'; -import bundleSource from '@endo/bundle-source'; -import { writeFile } from 'fs/promises'; - -import { resolve } from './lib.mjs'; - -main(resolve('vat.js'), resolve('vat.bundle')).catch(console.error); - -/** - * - * @param source - * @param target - */ -async function main(source, target) { - console.log('bundleSource', bundleSource); - const bundle = await bundleSource(source); - const bundleString = JSON.stringify(bundle); - await writeFile(target, bundleString); - console.log(`wrote ${target}: ${new Blob([bundleString]).size} bytes`); -} diff --git a/packages/nodejs/src/bundle-example/lib.mjs b/packages/nodejs/src/bundle-example/lib.mjs deleted file mode 100644 index 18f17a3ab..000000000 --- a/packages/nodejs/src/bundle-example/lib.mjs +++ /dev/null @@ -1,23 +0,0 @@ -const { promises } = await import('fs'); -const url = await import('url'); - -/** - * Resolve a path given relative to this file. - * - * @param {string} relativePath - The path to load, relative to this file. - * @returns An absolute filepath. - */ -export function resolve(relativePath) { - return url.fileURLToPath(new URL(relativePath, import.meta.url)); -} - -/** - * Load the content from the file at the given filepath. - * - * @param {string} relativePath - The path to load, relative to this file. - * @returns The data stored in filepath. - */ -export async function getContent(relativePath) { - const rawContent = await promises.readFile(resolve(relativePath)); - return rawContent.toString(); -} diff --git a/packages/nodejs/src/bundle-example/vat.bundle b/packages/nodejs/src/bundle-example/vat.bundle deleted file mode 100644 index 50e26f8ca..000000000 --- a/packages/nodejs/src/bundle-example/vat.bundle +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"87c9ac097da785a31633b0728073f2f837c6807b9a086923f20382261f19c1c5428b050b2545c004695f3fe90664b3bfd5d08ba7483f145593a2b29be1ad8504"} \ No newline at end of file diff --git a/packages/nodejs/src/bundle-example/vat.js b/packages/nodejs/src/bundle-example/vat.js deleted file mode 100644 index c18708b02..000000000 --- a/packages/nodejs/src/bundle-example/vat.js +++ /dev/null @@ -1,27 +0,0 @@ -import { Far } from '@endo/marshal'; - -import { getContent } from './lib.mjs'; - -/** - * Build function for the vat. - * - * @param {unknown} parameters - Initialization parameters from the vat's config object. - * @returns {unknown} The root object for the new vat. - */ -export function buildRootObject(parameters) { - const filepath = parameters?.filepath ?? 'data.json'; - console.log('buildRootObject', filepath); - - let content; - - return Far('root', { - async bootstrap() { - content = await getContent(filepath); - console.log('bootstrap', filepath); - }, - read() { - console.log(content); - return content; - }, - }); -} From a1af352a488e90ab75019200cc20ec3bb151bff5 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 12:53:51 -0400 Subject: [PATCH 49/55] remove unused llm test --- packages/nodejs/package.json | 2 -- packages/nodejs/vitest.config.llm.ts | 30 ---------------------------- 2 files changed, 32 deletions(-) delete mode 100644 packages/nodejs/vitest.config.llm.ts diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index c7a91e070..c11a0141d 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -33,9 +33,7 @@ "publish:preview": "yarn npm publish --tag preview", "test": "vitest run --config vitest.config.ts", "test:e2e": "vitest run --config vitest.config.e2e.ts", - "test:llm": "vitest run --config vitest.config.llm.ts", "test:e2e:ci": "./scripts/test-e2e-ci.sh", - "test:llm:ci": "./scripts/test-llm-ci.sh", "test:clean": "yarn test --no-cache --coverage.clean", "test:dev": "yarn test --mode development", "test:verbose": "yarn test --reporter verbose", diff --git a/packages/nodejs/vitest.config.llm.ts b/packages/nodejs/vitest.config.llm.ts deleted file mode 100644 index 9488f3ec7..000000000 --- a/packages/nodejs/vitest.config.llm.ts +++ /dev/null @@ -1,30 +0,0 @@ -// eslint-disable-next-line spaced-comment -/// - -import path from 'path'; -import { defineConfig, mergeConfig } from 'vite'; - -import defaultConfig from '../../vitest.config.js'; - -const config = mergeConfig( - defaultConfig, - defineConfig({ - optimizeDeps: { include: ['better-sqlite3'] }, - test: { - name: 'nodejs:llm', - pool: 'forks', - alias: [ - { - find: '@ocap/shims/endoify', - replacement: path.resolve('../shims/src/endoify.js'), - customResolver: (id) => ({ external: true, id }), - }, - ], - include: ['./test/llm/**/*.test.ts'], - exclude: ['./src/**/*', './test/e2e/**/*'], - }, - }), -); - -delete config.test.coverage.thresholds; -export default config; From d7105f86761405f9bf9354f30f7fa4ed95122a3e Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 13:42:24 -0400 Subject: [PATCH 50/55] lint --- packages/nodejs/scripts/call-ollama.js | 3 +- packages/nodejs/src/demo/console/run.ts | 12 ++-- .../src/demo/console/subclusterConfig.ts | 3 +- .../src/demo/console/vats/asyncGenerator.js | 12 ++-- packages/nodejs/src/demo/console/vats/boot.js | 2 +- packages/nodejs/src/demo/rag/README.md | 5 ++ packages/nodejs/src/demo/rag/SETUP.md | 22 +++++- .../nodejs/src/demo/rag/documents/root.ts | 4 +- .../src/demo/rag/models/pull-and-make.ts | 22 ++++-- packages/nodejs/src/demo/rag/run.ts | 16 ++--- .../nodejs/src/demo/rag/subclusterConfig.ts | 5 +- packages/nodejs/src/demo/rag/user.ts | 5 +- packages/nodejs/src/demo/rag/vats/boot.js | 11 ++- packages/nodejs/src/demo/rag/vats/llm.js | 3 +- packages/nodejs/src/demo/rag/vats/user.js | 41 ++++++----- .../nodejs/src/demo/rag/vats/vectorStore.js | 44 +++++++----- packages/nodejs/src/demo/stream.ts | 66 +++++++++++++----- .../nodejs/src/kernel/VatWorkerService.ts | 7 +- .../nodejs/src/kernel/make-kernel.test.ts | 2 +- .../nodejs/src/vat/powers/load-document.ts | 69 ++++++++++++------- packages/nodejs/src/vat/powers/make-powers.ts | 8 +-- packages/nodejs/src/vat/powers/ollama.ts | 14 ++-- .../nodejs/src/vat/powers/vector-store.ts | 31 ++++++--- 23 files changed, 262 insertions(+), 145 deletions(-) diff --git a/packages/nodejs/scripts/call-ollama.js b/packages/nodejs/scripts/call-ollama.js index cf9ade805..6d9dc2552 100644 --- a/packages/nodejs/scripts/call-ollama.js +++ b/packages/nodejs/scripts/call-ollama.js @@ -2,8 +2,9 @@ import { readFile } from 'fs/promises'; import ollama from 'ollama'; /** + * Streams the response from Ollama to the console. * - * @param response + * @param {*} response - The response from Ollama. */ async function streamResponse(response) { const thinkEndToken = ''; diff --git a/packages/nodejs/src/demo/console/run.ts b/packages/nodejs/src/demo/console/run.ts index 304bfe34c..603b91967 100644 --- a/packages/nodejs/src/demo/console/run.ts +++ b/packages/nodejs/src/demo/console/run.ts @@ -4,22 +4,22 @@ import { Kernel } from '@ocap/kernel'; import type { ClusterConfig } from '@ocap/kernel'; import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; -import { makeKernel } from '../../kernel/make-kernel.js'; -import { makeSubclusterConfig } from './subclusterConfig.js'; +import { makeSubclusterConfig } from './subclusterConfig.ts'; +import { makeKernel } from '../../kernel/make-kernel.ts'; const args = { verbose: process.argv.includes('--verbose'), -} +}; main(args).catch(console.error); /** * The main function for the demo. * - * @param options0 - * @param options0.verbose + * @param options0 - The options for the demo. + * @param options0.verbose - Whether to run the demo in verbose mode. */ -async function main({ verbose }: { verbose: boolean }) { +async function main({ verbose }: { verbose: boolean }): Promise { // This port does nothing; we don't talk to the Kernel via a console (yet). const kernelPort = new NodeMessageChannel().port1; diff --git a/packages/nodejs/src/demo/console/subclusterConfig.ts b/packages/nodejs/src/demo/console/subclusterConfig.ts index ba6125cfb..eeb68b56c 100644 --- a/packages/nodejs/src/demo/console/subclusterConfig.ts +++ b/packages/nodejs/src/demo/console/subclusterConfig.ts @@ -1,6 +1,7 @@ import type { ClusterConfig } from '@ocap/kernel'; -const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; +const makeBundleSpec = (name: string): string => + `http://localhost:3000/${name}.bundle`; export const makeSubclusterConfig = (verbose: boolean): ClusterConfig => ({ bootstrap: 'boot', diff --git a/packages/nodejs/src/demo/console/vats/asyncGenerator.js b/packages/nodejs/src/demo/console/vats/asyncGenerator.js index 0c6fb5d7c..c76fa310c 100644 --- a/packages/nodejs/src/demo/console/vats/asyncGenerator.js +++ b/packages/nodejs/src/demo/console/vats/asyncGenerator.js @@ -1,4 +1,5 @@ import { Far } from '@endo/marshal'; + import { makeLogger } from '../../../../dist/demo/logger.mjs'; import { makeStreamMaker } from '../../../../dist/demo/stream.mjs'; @@ -14,6 +15,7 @@ import { makeStreamMaker } from '../../../../dist/demo/stream.mjs'; */ export function buildRootObject(vatPowers, parameters, _baggage) { const { verbose } = parameters; + // eslint-disable-next-line no-shadow const { setInterval, clearInterval } = vatPowers; const logger = makeLogger({ label: 'asyncGen', verbose }); @@ -25,7 +27,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { const makeCounter = (start = 0, ms = 100) => { const { id, writer } = makeStream(); let count = start; - + const interval = setInterval(async () => { const thisCount = count; count += 1; @@ -38,9 +40,9 @@ export function buildRootObject(vatPowers, parameters, _baggage) { counters.delete(id); }; - counters.set(id, harden({ stop })); + counters.set(id, { stop }); return id; - } + }; const getCounter = (id) => { const counter = counters.get(id); @@ -48,7 +50,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { throw new Error(`No such counterId ${id}`, { cause: id }); } return counter; - } + }; return Far('root', { async ping() { @@ -59,7 +61,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { async stop(counterId) { verbose && logger.debug(`stopping [${counterId}]`); await getCounter(counterId).stop(); - return true; + return removeStream(counterId); }, }); } diff --git a/packages/nodejs/src/demo/console/vats/boot.js b/packages/nodejs/src/demo/console/vats/boot.js index f8e2c41a6..b61c6b1de 100644 --- a/packages/nodejs/src/demo/console/vats/boot.js +++ b/packages/nodejs/src/demo/console/vats/boot.js @@ -50,7 +50,7 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { } display(count); } - } + }; await Promise.all([ readCounter(counterReader0, 10, counter0), diff --git a/packages/nodejs/src/demo/rag/README.md b/packages/nodejs/src/demo/rag/README.md index 8b42503c9..3212914d7 100644 --- a/packages/nodejs/src/demo/rag/README.md +++ b/packages/nodejs/src/demo/rag/README.md @@ -1,16 +1,21 @@ # RAG Demo + For this demo, we'll be connecting to a locally hosted LLM over the ollama API. Follow the [setup guide](./SETUP.md) to get your ollama running on `localhost:11434`. If you prefer to figure things out yourself, [have at](https://ollama.com/). ### Start Ocap CLI + From the `@ocap/nodejs` package, run this in one terminal. + ```sh yarn ocap start src/demo/rag/vats ``` ### Run RAG Demo + And then run this in another terminal. + ```sh yarn demo:rag ``` diff --git a/packages/nodejs/src/demo/rag/SETUP.md b/packages/nodejs/src/demo/rag/SETUP.md index e63074e92..94ba5840f 100644 --- a/packages/nodejs/src/demo/rag/SETUP.md +++ b/packages/nodejs/src/demo/rag/SETUP.md @@ -1,4 +1,5 @@ # Setup + The [demo](./README.md) uses a local large language model. This guide will help you install one. If you are on a Mac, use the MacOS instructions to get automatic GPU integration via the ollama app. Docker won't connect to the GPU on a Mac. @@ -6,62 +7,81 @@ If you are on a Mac, use the MacOS instructions to get automatic GPU integration Otherwise, use the Docker instructions, and consider the NVIDIA container setup to get GPU integration. We'll be using the deepseek-r1 model, which comes in several brain sizes. + - For a weak workstation, try the smallest brained `1.5b` - For a MacBook Pro type machine try `7b` -- If you have a beefier machine you might try bigger brain models. +- If you have a beefier machine you might try bigger brain models. ## MacOS + ### Download Ollama + Get the [ollama app](https://ollama.com/download/mac) and use it to install the ollama CLI. ### Pull DeepSeek-R1 + For a MacBook you might try the 7B, but you can do 1.5B if you're light on space. Smol brain: + ```sh ollama pull deepseek-r1:1.5b ``` Mid curve: + ```sh ollama pull deepseek-r1:7b ``` ## Docker + ### Get Docker + If you aren't familiar, you can just download the [desktop version](https://docs.docker.com/desktop/). ### Pull Ollama + If you downloaded the desktop version, search 'ollama' and pull the `ollama/ollama` image. Or run this in your terminal. + ```sh docker pull ollama/ollama ``` ### Start Ollama Container + You can just run things. + ```sh docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama ``` ### Pull DeepSeek-R1 + Smol brain: + ```sh curl -X POST http://localhost:11434/api/pull -d '{"model": "deepseek-r1:1.5b"}' ``` Mid curve: + ```sh curl -X POST http://localhost:11434/api/pull -d '{"model": "deepseek-r1:7b"}' ``` ### Local Llama on a GPU + Peep the [ollama docs](https://github.com/ollama/ollama/blob/main/docs/docker.md) if you want to dock your local llama on a GPU. # Check Your Llama + At this point, if you open a browser and navigate to `localhost:11434` you should see the following message. + ``` Ollama is running ``` + If you do, you're ready for the [demo](./README.md)! diff --git a/packages/nodejs/src/demo/rag/documents/root.ts b/packages/nodejs/src/demo/rag/documents/root.ts index de661db05..3f4e29795 100644 --- a/packages/nodejs/src/demo/rag/documents/root.ts +++ b/packages/nodejs/src/demo/rag/documents/root.ts @@ -1,5 +1,5 @@ -import { resolve } from "path"; +import { resolve } from 'path'; export const documentRoot = resolve( - new URL('content', import.meta.url).pathname + new URL('content', import.meta.url).pathname, ).replace(/\/dist\//u, '/src/'); diff --git a/packages/nodejs/src/demo/rag/models/pull-and-make.ts b/packages/nodejs/src/demo/rag/models/pull-and-make.ts index aec5babc0..a67f7d868 100644 --- a/packages/nodejs/src/demo/rag/models/pull-and-make.ts +++ b/packages/nodejs/src/demo/rag/models/pull-and-make.ts @@ -1,4 +1,5 @@ import { Ollama } from 'ollama'; +import type { ProgressResponse } from 'ollama'; const ollama = new Ollama({ host: 'http://localhost:11434' }); @@ -9,31 +10,38 @@ const models = { embeddings: ['mxbai-embed-large'], }; -const make8kModel = async (model: string) => +const make8kModel = async (model: string): Promise => ollama.create({ model: `${model}-${affix8k}`, from: model, parameters: { + // The `num_ctx` parameter denotes the context window size. + // Blame python for the snake_case naming convention. + // eslint-disable-next-line @typescript-eslint/naming-convention num_ctx: 8096, }, }); const pull = async ( modelsToPull: string[] = [...models.llm, ...models.embeddings], -) => { - await Promise.all(modelsToPull.map(async (model) => ollama.pull({ model }))); +): Promise => { + return await Promise.all( + modelsToPull.map(async (model) => ollama.pull({ model })), + ); }; const make8kLLMs = async ( modelsToMake: string[] = [...models.llm, ...models.embeddings], -) => { - await Promise.all(modelsToMake.map(async (model) => make8kModel(model))); +): Promise => { + return await Promise.all( + modelsToMake.map(async (model) => make8kModel(model)), + ); }; /** - * + * Pull and make the models. */ -export default async function main() { +export default async function main(): Promise { console.log('pulling models', models); await pull(); console.log('making large context models', models.llm); diff --git a/packages/nodejs/src/demo/rag/run.ts b/packages/nodejs/src/demo/rag/run.ts index 98d2fcefe..5e77d4052 100644 --- a/packages/nodejs/src/demo/rag/run.ts +++ b/packages/nodejs/src/demo/rag/run.ts @@ -4,23 +4,23 @@ import { Kernel } from '@ocap/kernel'; import type { ClusterConfig } from '@ocap/kernel'; import { MessageChannel as NodeMessageChannel } from 'node:worker_threads'; -import { makeKernel } from '../../kernel/make-kernel.js'; -import { makeSubclusterConfig } from './subclusterConfig.js'; -import { documentRoot } from './documents/root.js'; +import { documentRoot } from './documents/root.ts'; +import { makeSubclusterConfig } from './subclusterConfig.ts'; +import { makeKernel } from '../../kernel/make-kernel.ts'; const args = { verbose: process.argv.includes('--verbose'), -} +}; main(args).catch(console.error); /** * The main function for the demo. * - * @param options0 - * @param options0.verbose + * @param options0 - The options for the demo. + * @param options0.verbose - Whether to run the demo in verbose mode. */ -async function main({ verbose }: { verbose: boolean }) { +async function main({ verbose }: { verbose: boolean }): Promise { // This port does nothing; we don't talk to the Kernel via a console (yet). const kernelPort = new NodeMessageChannel().port1; @@ -29,7 +29,7 @@ async function main({ verbose }: { verbose: boolean }) { port: kernelPort, vatWorkerServiceOptions: { makeDocumentRoot: async () => documentRoot, - } + }, }); const config: ClusterConfig = makeSubclusterConfig(verbose); await kernel.launchSubcluster(config); diff --git a/packages/nodejs/src/demo/rag/subclusterConfig.ts b/packages/nodejs/src/demo/rag/subclusterConfig.ts index df315491e..b9b748288 100644 --- a/packages/nodejs/src/demo/rag/subclusterConfig.ts +++ b/packages/nodejs/src/demo/rag/subclusterConfig.ts @@ -3,7 +3,8 @@ import type { ClusterConfig, VatConfig } from '@ocap/kernel'; type ModelSize = '1.5b' | '7b' | '8b' | '14b' | '32b' | '70b' | '671b'; type Model = `deepseek-r1:${ModelSize}${string}`; -const makeBundleSpec = (name: string) => `http://localhost:3000/${name}.bundle`; +const makeBundleSpec = (name: string): string => + `http://localhost:3000/${name}.bundle`; type UserConfig = { model: Model; @@ -107,4 +108,4 @@ export const makeSubclusterConfig = (verbose: boolean): ClusterConfig => { ...eveConfig, }, }; -} +}; diff --git a/packages/nodejs/src/demo/rag/user.ts b/packages/nodejs/src/demo/rag/user.ts index af53be24a..3b332b636 100644 --- a/packages/nodejs/src/demo/rag/user.ts +++ b/packages/nodejs/src/demo/rag/user.ts @@ -12,10 +12,7 @@ export const makeInitUser = ( logger.debug('initUser:user', user); const languageModel = vats[`${user}.llm`]; const vectorStore = vats[`${user}.vectorStore`]; - await Promise.all([ - E(languageModel).init(), - E(vectorStore).init(), - ]); + await Promise.all([E(languageModel).init(), E(vectorStore).init()]); const defaultDocumentView = await E(vectorStore).makeDocumentView(); const response = await E(vats[user]).init( languageModel, diff --git a/packages/nodejs/src/demo/rag/vats/boot.js b/packages/nodejs/src/demo/rag/vats/boot.js index b4ca8f8a8..c90b2ebc0 100644 --- a/packages/nodejs/src/demo/rag/vats/boot.js +++ b/packages/nodejs/src/demo/rag/vats/boot.js @@ -33,9 +33,14 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { console.time('bootstrap'); const initUser = makeInitUser(vats, logger); - await Promise.all(users.map( - (user) => initUser(user, users.filter(peer => peer !== user)), - )); + await Promise.all( + users.map((user) => + initUser( + user, + users.filter((peer) => peer !== user), + ), + ), + ); console.timeEnd('bootstrap'); display('Initialized'); diff --git a/packages/nodejs/src/demo/rag/vats/llm.js b/packages/nodejs/src/demo/rag/vats/llm.js index be99f0bd0..58a16c46c 100644 --- a/packages/nodejs/src/demo/rag/vats/llm.js +++ b/packages/nodejs/src/demo/rag/vats/llm.js @@ -1,5 +1,6 @@ import { Far } from '@endo/marshal'; import { makePipe } from '@endo/stream'; + import { makeLogger } from '../../../../dist/demo/logger.mjs'; // The default LLM model to use. @@ -22,7 +23,7 @@ const parseResponse = (response) => { * always* generated as complete tokens, and *never* partially as strings. * * @param {*} response - An async generator yielding a deepseek token stream. - * @returns An object with async generator properties 'thought' and 'speech'. + * @returns {object} An object with async generator properties 'thought' and 'speech'. */ const parseResponseStream = (response) => { const [thought, thoughtWriter] = makePipe(); diff --git a/packages/nodejs/src/demo/rag/vats/user.js b/packages/nodejs/src/demo/rag/vats/user.js index c3597f682..040849818 100644 --- a/packages/nodejs/src/demo/rag/vats/user.js +++ b/packages/nodejs/src/demo/rag/vats/user.js @@ -15,18 +15,18 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { const logger = { log: console.log, - debug: verbose ? console.debug : () => {}, + debug: verbose ? console.debug : () => undefined, error: console.error, }; const caps = { languageModel: undefined, documentViews: new Map(), - } + }; const getDocumentView = (user) => { return caps.documentViews.get(user) ?? caps.documentViews.get('default'); - } + }; const messageHistory = []; const pushMessage = (message) => messageHistory.push(message); @@ -63,11 +63,11 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { * Validate that the JSON response meets its schema, given some parameters. * * XXX This validation logic is hardcoded. - * XXX Ideal would be to have a tree-shaken langchainjs import available + * XXX Ideal would be to have a tree-shaken langchainjs import available. * - * @param {*} response - The response to be validated. - * @param {*} params - Parameters for validating the response. - * @param parsedResponse + * @param {string} parsedResponse - The parsed response to be validated. + * @param {object} context - The context in which the response is being validated. + * @param {string} context.responder - The name of the responder. */ const validateProposeNextMessageResponse = ( parsedResponse, @@ -244,12 +244,15 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { }; /** + * Process a message from a sender. * - * @param sender - * @param message - * @param conversationHistory + * @param {string} sender - The sender of the message. + * @param {object} message - The message to be processed. + * @param {object} context - The context in which the message is being processed. + * @param {object[]} context.conversationHistory - The history of messages in the conversation. + * @returns {Promise} The response to the message. */ - async function processMessage(sender, message, conversationHistory) { + async function processMessage(sender, message, { conversationHistory }) { // XXX Fallaciously assume the caller has truthfully self-identified. const knowledge = await E(getDocumentView(sender)).query(message.content); logger.debug('user.processMessage:knowledge', knowledge); @@ -267,10 +270,10 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { return Far('root', { /** * Initialize the vat's peer capabilities. - * + * * @param {*} languageModel - A llm capability for next token generation. * @param {*} documentView - The default DocumentView. - * @returns A result object with some currently unutilized properties. + * @returns {Promise} A result object with some currently unutilized properties. */ async init(languageModel, documentView) { caps.languageModel = languageModel; @@ -279,8 +282,10 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { return { name, stream }; }, - getTrust(user) { return trust[user] ?? 0.0; }, - setPeerDocumentView (peer, documentView) { + getTrust(user) { + return trust[user] ?? 0.0; + }, + setPeerDocumentView(peer, documentView) { caps.documentViews.set(peer, documentView); }, @@ -288,11 +293,9 @@ export function buildRootObject(_vatPowers, parameters, _baggage) { const message = { sender, recipient: name, content }; const conversationHistory = getConversation(sender); pushMessage(message); - const response = await processMessage( - sender, - message, + const response = await processMessage(sender, message, { conversationHistory, - ).catch((problem) => { + }).catch((problem) => { logger.error(problem); return 'Error: bad brain'; }); diff --git a/packages/nodejs/src/demo/rag/vats/vectorStore.js b/packages/nodejs/src/demo/rag/vats/vectorStore.js index 91a5175f0..46882620f 100644 --- a/packages/nodejs/src/demo/rag/vats/vectorStore.js +++ b/packages/nodejs/src/demo/rag/vats/vectorStore.js @@ -1,4 +1,5 @@ import { Far } from '@endo/marshal'; + import { makeLogger } from '../../../../dist/demo/logger.mjs'; /** @@ -20,25 +21,24 @@ export function buildRootObject(vatPowers, parameters, _baggage) { // By default, every stored document is maximally private. const DEFAULT_DOCUMENT_SECRECY = 1.0; const addDocuments = async (docs) => { - logger.debug( - 'addDocuments:docs', - JSON.stringify(docs, null, 2), - ); - return await vectorStore.addDocuments(docs.map( - (doc) => ({ + logger.debug('addDocuments:docs', JSON.stringify(docs, null, 2)); + return await vectorStore.addDocuments( + docs.map((doc) => ({ pageContent: doc.pageContent, metadata: { secrecy: DEFAULT_DOCUMENT_SECRECY, ...doc.metadata, }, - }), - )); - } + })), + ); + }; // By default, views return only public documents, const DEFAULT_QUERY_SECRECY = 0.0; - const makeSecrecyFilter = (secrecy = DEFAULT_QUERY_SECRECY) => - (doc) => doc.metadata.secrecy <= secrecy; + const makeSecrecyFilter = + (secrecy = DEFAULT_QUERY_SECRECY) => + (doc) => + doc.metadata.secrecy <= secrecy; // and not very many. const DEFAULT_QUERY_MAX_RESULTS = 3; @@ -49,29 +49,35 @@ export function buildRootObject(vatPowers, parameters, _baggage) { let revoked = false; const filter = makeSecrecyFilter(secrecy); const query = async (topic, nResults) => { - if (revoked) { return []; } + if (revoked) { + return []; + } const results = await vectorStore.similaritySearchWithScore( - topic, nResults < maxResults ? nResults : maxResults, filter, - ) + topic, + nResults < maxResults ? nResults : maxResults, + filter, + ); return results.map(([doc, score]) => ({ pageContent: doc.pageContent, metadata: { relevance: score, ...doc.metadata }, - }));; + })); }; return Far('DocumentView', { query, getParameters: () => ({ maxResults }), - revoke: () => { revoked = true; }, + revoke: () => { + revoked = true; + }, isRevoked: () => revoked, }); - } + }; return Far('root', { async init() { logger.debug('init'); await ollama.pull({ model }); - const chunks = await Promise.all(documents.map( - async ({ path, secrecy }) => { + const chunks = await Promise.all( + documents.map(async ({ path, secrecy }) => { logger.debug({ path, secrecy }); return await loadDocument(path, secrecy); }), diff --git a/packages/nodejs/src/demo/stream.ts b/packages/nodejs/src/demo/stream.ts index 14db4d871..086258423 100644 --- a/packages/nodejs/src/demo/stream.ts +++ b/packages/nodejs/src/demo/stream.ts @@ -1,22 +1,24 @@ -import { E } from "@endo/eventual-send"; -import { makePipe, type Reader, type Writer } from "@endo/stream"; +import { E } from '@endo/eventual-send'; +import { makePipe } from '@endo/stream'; +import type { Reader, Writer } from '@endo/stream'; /** * Type representing a remote vat that exposes stream methods */ type RemoteStreamVat = { - streamReadNext: (id: number) => Promise, - streamReadThrow: (id: number, error: Error) => Promise, - streamReadReturn: (id: number) => Promise, + streamReadNext: (id: number) => Promise; + streamReadThrow: (id: number, error: Error) => Promise; + streamReadReturn: (id: number) => Promise; }; /** * Creates a local stream reader that forwards operations to a remote vat's stream + * * @param vat - The remote vat that manages the actual stream * @returns A hardened stream reader that implements the async iterator protocol */ -export const makeVatStreamReader = (vat: RemoteStreamVat) => - (streamId: number) => { +export const makeVatStreamReader = + (vat: RemoteStreamVat) => (streamId: number) => { const streamReader = { async next() { return E(vat).streamReadNext(streamId); @@ -27,30 +29,47 @@ export const makeVatStreamReader = (vat: RemoteStreamVat) => async return() { return E(vat).streamReadReturn(streamId); }, - [Symbol.asyncIterator]() { + [Symbol.asyncIterator]() { return this; }, }; return streamReader; - } + }; -type Stream = { +type Stream = { id: number; reader: Reader; writer: Writer; }; +type StreamMaker = { + makeStream: () => Stream; + readStreamFacet: { + streamReadNext: (id: number) => Promise>; + streamReadThrow: ( + id: number, + error: Error, + ) => Promise>; + streamReadReturn: ( + id: number, + ) => Promise>; + }; + removeStream: (id: number) => void; +}; + /** * Creates a stream manager for the remote vat that maintains stream references * and exposes methods to create and access streams + * * @returns A hardened object with methods to create and access streams */ -export const makeStreamMaker = () => { +export const makeStreamMaker = (): StreamMaker => { let counter = 0; const streams = new Map(); /** * Creates a new stream and returns its ID + * * @returns The ID of the newly created stream */ const makeStream = (): Stream => { @@ -64,33 +83,42 @@ export const makeStreamMaker = () => { /** * Retrieves a stream by its ID and returns a Far reference to its reader + * * @param id - The ID of the stream to retrieve * @returns A Far reference to the stream reader * @throws If no stream exists with the given ID */ - const getStream = (id: number) => { + const getStream = (id: number): Stream => { const stream = streams.get(id); if (!stream) { throw new Error(`No stream with id ${id}`); } return stream; - } + }; - const streamReadNext = async (id: number) => { + const streamReadNext = async ( + id: number, + ): Promise> => { const stream = getStream(id); return await stream.reader.next(undefined); - } - const streamReadThrow = async (id: number, error: Error) => { + }; + const streamReadThrow = async ( + id: number, + error: Error, + ): Promise> => { const stream = getStream(id); return await stream.reader.throw(error); - } - const streamReadReturn = async (id: number) => { + }; + const streamReadReturn = async ( + id: number, + ): Promise> => { const stream = getStream(id); return await stream.reader.return(undefined); - } + }; /** * Removes a stream from the manager + * * @param id - The ID of the stream to remove */ const removeStream = (id: number): void => { diff --git a/packages/nodejs/src/kernel/VatWorkerService.ts b/packages/nodejs/src/kernel/VatWorkerService.ts index c0d98adbf..6ca79c1e2 100644 --- a/packages/nodejs/src/kernel/VatWorkerService.ts +++ b/packages/nodejs/src/kernel/VatWorkerService.ts @@ -24,18 +24,18 @@ const DEFAULT_WORKER_FILE = new URL( export type MakeDocumentRoot = (vatId: VatId) => Promise; -const makeDocumentRootDefault = async (vatId: VatId) => { +const makeDocumentRootDefault = async (vatId: VatId): Promise => { const root = join(tmpdir(), 'vats', vatId); await mkdir(root, { recursive: true }); return root; -} +}; export class NodejsVatWorkerService implements VatWorkerService { readonly #logger: Logger; readonly #workerFilePath: string; - readonly #makeDocumentRoot: MakeDocumentRoot; + readonly #makeDocumentRoot: MakeDocumentRoot; workers = new Map< VatId, @@ -49,6 +49,7 @@ export class NodejsVatWorkerService implements VatWorkerService { * @param args - A bag of optional arguments. * @param args.workerFilePath - An optional path to a file defining the worker's routine. Defaults to 'vat-worker.mjs'. * @param args.logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'. + * @param args.makeDocumentRoot - An optional function that returns a path to a directory for storing documents. Defaults to a function that creates a directory in the system temp directory. */ constructor(args: { workerFilePath?: string | undefined; diff --git a/packages/nodejs/src/kernel/make-kernel.test.ts b/packages/nodejs/src/kernel/make-kernel.test.ts index e45982464..47991ea5a 100644 --- a/packages/nodejs/src/kernel/make-kernel.test.ts +++ b/packages/nodejs/src/kernel/make-kernel.test.ts @@ -24,7 +24,7 @@ describe('makeKernel', () => { }); it('should return a Kernel', async () => { - const kernel = await makeKernel(kernelPort); + const kernel = await makeKernel({ port: kernelPort }); expect(kernel).toBeInstanceOf(Kernel); }); diff --git a/packages/nodejs/src/vat/powers/load-document.ts b/packages/nodejs/src/vat/powers/load-document.ts index 7cd1e6374..fc44b4cf5 100644 --- a/packages/nodejs/src/vat/powers/load-document.ts +++ b/packages/nodejs/src/vat/powers/load-document.ts @@ -1,26 +1,40 @@ +import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters'; +import { readFile } from 'fs/promises'; +import { tmpdir } from 'os'; +import { join } from 'path'; -import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters"; -import { readFile } from "fs/promises"; -import { tmpdir } from "os"; -import { join } from "path"; +export type Args = + | { + useTmpDir?: boolean; + root: string; + } + | { + useTmpDir: true; + root?: never; + }; -export type Args = { - useTmpDir?: boolean, - root: string, -} | { - useTmpDir: true, - root?: never, -} +type LoadDocument = ( + name: string, + secrecy: string, +) => Promise< + { + pageContent: string; + metadata: { source: string; secrecy: string }; + }[] +>; /** * Makes a view which loads .txt documents from the root - * + * * @param args - The arguments * @param args.root - The base filepath to load documents from. * @param args.useTmpDir - Whether to . - * @returns A method for loading a document by name. + * @returns A method for loading a document by name. */ -export default function makeLoadDocument({ root, useTmpDir }: Args) { +export default function makeLoadDocument({ + root, + useTmpDir, +}: Args): LoadDocument { if (root === undefined && useTmpDir === undefined) { throw new Error('Bad arguments', { cause: { root, useTmpDir } }); } @@ -29,11 +43,11 @@ export default function makeLoadDocument({ root, useTmpDir }: Args) { base = base ? join(base, root) : root; } // XXX name might exit 'base' via '..'s or symlinks - const resolve = (name: string) => `${base}/${name}.txt`; + const resolve = (name: string): string => `${base}/${name}.txt`; - const loadDocument = async (name: string, secrecy: string) => { + const loadDocument: LoadDocument = async (name: string, secrecy: string) => { const source = resolve(name); - const pageContent = await readFile(source, "utf8"); + const pageContent = await readFile(source, 'utf8'); if (!pageContent) { throw new Error(`Could not find document ${name}`); } @@ -41,16 +55,21 @@ export default function makeLoadDocument({ root, useTmpDir }: Args) { chunkSize: 384, chunkOverlap: 64, }); - const splitDocs = await splitter.splitDocuments([{ - pageContent, + const splitDocs = await splitter.splitDocuments([ + { + pageContent, + metadata: {}, + }, + ]); + if (!splitDocs.length) { + throw new Error(`Document ${name} produced no content after splitting`); + } + return splitDocs.map((doc) => ({ + pageContent: doc.pageContent, // XXX secrecy should be handled in a separate routine - metadata: { source: name, secrecy }, - }]); - return splitDocs.map((document) => ({ - pageContent: document.pageContent, - metadata: { ...document.metadata }, + metadata: { source: name, secrecy, ...doc.metadata }, })); - } + }; return loadDocument; } diff --git a/packages/nodejs/src/vat/powers/make-powers.ts b/packages/nodejs/src/vat/powers/make-powers.ts index e6be4aa6d..fbcb7e93d 100644 --- a/packages/nodejs/src/vat/powers/make-powers.ts +++ b/packages/nodejs/src/vat/powers/make-powers.ts @@ -1,7 +1,7 @@ -import makeLoadDocument from './load-document'; -import type { Args as LoadDocumentArgs } from './load-document.js'; -import makeGetOllama from './ollama'; -import makeGetVectorStore from './vector-store'; +import makeLoadDocument from './load-document.ts'; +import type { Args as LoadDocumentArgs } from './load-document.ts'; +import makeGetOllama from './ollama.ts'; +import makeGetVectorStore from './vector-store.ts'; type Args = { loadDocument?: LoadDocumentArgs; diff --git a/packages/nodejs/src/vat/powers/ollama.ts b/packages/nodejs/src/vat/powers/ollama.ts index e8d8ab018..a60371807 100644 --- a/packages/nodejs/src/vat/powers/ollama.ts +++ b/packages/nodejs/src/vat/powers/ollama.ts @@ -1,10 +1,12 @@ -import { Ollama } from "ollama"; +import { Ollama } from 'ollama'; /** * Returns a promise that resolves when the ollama service is running, * or rejects if the API is unreachable. + * + * @param host - The url to reach the local ollama server. */ -export const ollamaOnline = async (host: string) => { +export const ollamaOnline = async (host: string): Promise => { const response = await (await fetch(host)).text(); const expectation = 'Ollama is running'; if (response !== expectation) { @@ -14,13 +16,17 @@ export const ollamaOnline = async (host: string) => { /** * Ensure the ollama server is running and return a connection to it. - * + * * @param param0 - The args. * @param param0.host - The url to reach the local ollama server. * @returns An Ollama API object. * @throws If the ollama server cannot be reached at the provided host url. */ -export default async function makeOllama({ host } : {host: string}) { +export default async function makeOllama({ + host, +}: { + host: string; +}): Promise { await ollamaOnline(host); return new Ollama({ host }); } diff --git a/packages/nodejs/src/vat/powers/vector-store.ts b/packages/nodejs/src/vat/powers/vector-store.ts index 4f977ce58..78461c279 100644 --- a/packages/nodejs/src/vat/powers/vector-store.ts +++ b/packages/nodejs/src/vat/powers/vector-store.ts @@ -1,23 +1,36 @@ -import { OllamaEmbeddings } from "@langchain/ollama"; -import { MemoryVectorStore } from "langchain/vectorstores/memory"; +import { OllamaEmbeddings } from '@langchain/ollama'; +import { MemoryVectorStore } from 'langchain/vectorstores/memory'; type Args = { - host: string, - model?: string, -} + host: string; + model?: string; +}; + +type GetVectorStore = () => MemoryVectorStore; const DEFAULT_EMBED_MODEL = 'mxbai-embed-large-8k'; -export default function makeGetVectorStore({ host, model }: Args) { +/** + * Make a function that returns a vector store. + * + * @param options0 - The options for the vector store. + * @param options0.host - The host to reach the local ollama server. + * @param options0.model - The model to use for the vector store. + * @returns A function that returns a vector store. + */ +export default function makeGetVectorStore({ + host, + model, +}: Args): GetVectorStore { const embeddings = new OllamaEmbeddings({ baseUrl: host, model: model ?? DEFAULT_EMBED_MODEL, }); const vectorStore = new MemoryVectorStore(embeddings); - + // XXX Hardening the vectorStore renders it inoperational, so we wrap it in // an arrow function which returns a soft vectorStore even after hardening. - const getVectorStore = () => vectorStore; - + const getVectorStore = (): MemoryVectorStore => vectorStore; + return getVectorStore; } From 20e3fccd7b0a5500319ec493afed632c91e29860 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 15:22:51 -0400 Subject: [PATCH 51/55] remove unused deps --- packages/nodejs/package.json | 2 - yarn.lock | 480 +---------------------------------- 2 files changed, 5 insertions(+), 477 deletions(-) diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index c11a0141d..5eca2f6e5 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -44,10 +44,8 @@ "@endo/marshal": "^1.6.2", "@endo/promise-kit": "^1.1.6", "@endo/stream": "^1.2.6", - "@huggingface/transformers": "^3.3.2", "@langchain/core": "^0.3.37", "@langchain/ollama": "^0.1.5", - "@langchain/openai": "^0.4.2", "@langchain/textsplitters": "^0.1.0", "@ocap/kernel": "workspace:^", "@ocap/shims": "workspace:^", diff --git a/yarn.lock b/yarn.lock index 1352300fb..c1e04936c 100644 --- a/yarn.lock +++ b/yarn.lock @@ -511,15 +511,6 @@ __metadata: languageName: node linkType: hard -"@emnapi/runtime@npm:^1.2.0": - version: 1.3.1 - resolution: "@emnapi/runtime@npm:1.3.1" - dependencies: - tslib: "npm:^2.4.0" - checksum: 10/619915ee44682356f77f60455025e667b0b04ad3c95ced36c03782aea9ebc066fa73e86c4a59d221177eba5e5533d40b3a6dbff4e58ee5d81db4270185c21e22 - languageName: node - linkType: hard - "@endo/base64@npm:^1.0.9": version: 1.0.9 resolution: "@endo/base64@npm:1.0.9" @@ -1108,25 +1099,6 @@ __metadata: languageName: node linkType: hard -"@huggingface/jinja@npm:^0.3.2": - version: 0.3.3 - resolution: "@huggingface/jinja@npm:0.3.3" - checksum: 10/7ca60550a8fcd084a84c34bacb857f12d614ff77463883df824c8759cb29e4a45f87520a25ece9dd4f2ea7f72280883d8040a5cf959c459d586f33bb59450104 - languageName: node - linkType: hard - -"@huggingface/transformers@npm:^3.3.2": - version: 3.3.2 - resolution: "@huggingface/transformers@npm:3.3.2" - dependencies: - "@huggingface/jinja": "npm:^0.3.2" - onnxruntime-node: "npm:1.20.1" - onnxruntime-web: "npm:1.21.0-dev.20250114-228dd16893" - sharp: "npm:^0.33.5" - checksum: 10/ab60a206e4e2410b42c8face58cf2cb3c7655d1b4e2f119b117ba4a8a9eba3ec0194faf5901e793dc0a8f2b6703dadb59509da850ab3171374745a7119b3c24d - languageName: node - linkType: hard - "@humanfs/core@npm:^0.19.1": version: 0.19.1 resolution: "@humanfs/core@npm:0.19.1" @@ -1165,181 +1137,6 @@ __metadata: languageName: node linkType: hard -"@img/sharp-darwin-arm64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-darwin-arm64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-darwin-arm64": - optional: true - conditions: os=darwin & cpu=arm64 - languageName: node - linkType: hard - -"@img/sharp-darwin-x64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-darwin-x64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-darwin-x64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-darwin-x64": - optional: true - conditions: os=darwin & cpu=x64 - languageName: node - linkType: hard - -"@img/sharp-libvips-darwin-arm64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-darwin-arm64@npm:1.0.4" - conditions: os=darwin & cpu=arm64 - languageName: node - linkType: hard - -"@img/sharp-libvips-darwin-x64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-darwin-x64@npm:1.0.4" - conditions: os=darwin & cpu=x64 - languageName: node - linkType: hard - -"@img/sharp-libvips-linux-arm64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-linux-arm64@npm:1.0.4" - conditions: os=linux & cpu=arm64 & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-libvips-linux-arm@npm:1.0.5": - version: 1.0.5 - resolution: "@img/sharp-libvips-linux-arm@npm:1.0.5" - conditions: os=linux & cpu=arm & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-libvips-linux-s390x@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-linux-s390x@npm:1.0.4" - conditions: os=linux & cpu=s390x & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-libvips-linux-x64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-linux-x64@npm:1.0.4" - conditions: os=linux & cpu=x64 & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4" - conditions: os=linux & cpu=arm64 & libc=musl - languageName: node - linkType: hard - -"@img/sharp-libvips-linuxmusl-x64@npm:1.0.4": - version: 1.0.4 - resolution: "@img/sharp-libvips-linuxmusl-x64@npm:1.0.4" - conditions: os=linux & cpu=x64 & libc=musl - languageName: node - linkType: hard - -"@img/sharp-linux-arm64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linux-arm64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linux-arm64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-linux-arm64": - optional: true - conditions: os=linux & cpu=arm64 & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-linux-arm@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linux-arm@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linux-arm": "npm:1.0.5" - dependenciesMeta: - "@img/sharp-libvips-linux-arm": - optional: true - conditions: os=linux & cpu=arm & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-linux-s390x@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linux-s390x@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linux-s390x": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-linux-s390x": - optional: true - conditions: os=linux & cpu=s390x & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-linux-x64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linux-x64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linux-x64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-linux-x64": - optional: true - conditions: os=linux & cpu=x64 & libc=glibc - languageName: node - linkType: hard - -"@img/sharp-linuxmusl-arm64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linuxmusl-arm64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-linuxmusl-arm64": - optional: true - conditions: os=linux & cpu=arm64 & libc=musl - languageName: node - linkType: hard - -"@img/sharp-linuxmusl-x64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-linuxmusl-x64@npm:0.33.5" - dependencies: - "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" - dependenciesMeta: - "@img/sharp-libvips-linuxmusl-x64": - optional: true - conditions: os=linux & cpu=x64 & libc=musl - languageName: node - linkType: hard - -"@img/sharp-wasm32@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-wasm32@npm:0.33.5" - dependencies: - "@emnapi/runtime": "npm:^1.2.0" - conditions: cpu=wasm32 - languageName: node - linkType: hard - -"@img/sharp-win32-ia32@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-win32-ia32@npm:0.33.5" - conditions: os=win32 & cpu=ia32 - languageName: node - linkType: hard - -"@img/sharp-win32-x64@npm:0.33.5": - version: 0.33.5 - resolution: "@img/sharp-win32-x64@npm:0.33.5" - conditions: os=win32 & cpu=x64 - languageName: node - linkType: hard - "@inquirer/confirm@npm:^5.0.0": version: 5.1.6 resolution: "@inquirer/confirm@npm:5.1.6" @@ -1499,7 +1296,7 @@ __metadata: languageName: node linkType: hard -"@langchain/openai@npm:>=0.1.0 <0.5.0, @langchain/openai@npm:^0.4.2": +"@langchain/openai@npm:>=0.1.0 <0.5.0": version: 0.4.2 resolution: "@langchain/openai@npm:0.4.2" dependencies: @@ -2467,10 +2264,8 @@ __metadata: "@endo/marshal": "npm:^1.6.2" "@endo/promise-kit": "npm:^1.1.6" "@endo/stream": "npm:^1.2.6" - "@huggingface/transformers": "npm:^3.3.2" "@langchain/core": "npm:^0.3.37" "@langchain/ollama": "npm:^0.1.5" - "@langchain/openai": "npm:^0.4.2" "@langchain/textsplitters": "npm:^0.1.0" "@metamask/auto-changelog": "npm:^4.0.0" "@metamask/eslint-config": "npm:^14.0.0" @@ -2909,79 +2704,6 @@ __metadata: languageName: node linkType: hard -"@protobufjs/aspromise@npm:^1.1.1, @protobufjs/aspromise@npm:^1.1.2": - version: 1.1.2 - resolution: "@protobufjs/aspromise@npm:1.1.2" - checksum: 10/8a938d84fe4889411296db66b29287bd61ea3c14c2d23e7a8325f46a2b8ce899857c5f038d65d7641805e6c1d06b495525c7faf00c44f85a7ee6476649034969 - languageName: node - linkType: hard - -"@protobufjs/base64@npm:^1.1.2": - version: 1.1.2 - resolution: "@protobufjs/base64@npm:1.1.2" - checksum: 10/c71b100daeb3c9bdccab5cbc29495b906ba0ae22ceedc200e1ba49717d9c4ab15a6256839cebb6f9c6acae4ed7c25c67e0a95e734f612b258261d1a3098fe342 - languageName: node - linkType: hard - -"@protobufjs/codegen@npm:^2.0.4": - version: 2.0.4 - resolution: "@protobufjs/codegen@npm:2.0.4" - checksum: 10/c6ee5fa172a8464f5253174d3c2353ea520c2573ad7b6476983d9b1346f4d8f2b44aa29feb17a949b83c1816bc35286a5ea265ed9d8fdd2865acfa09668c0447 - languageName: node - linkType: hard - -"@protobufjs/eventemitter@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/eventemitter@npm:1.1.0" - checksum: 10/03af3e99f17ad421283d054c88a06a30a615922a817741b43ca1b13e7c6b37820a37f6eba9980fb5150c54dba6e26cb6f7b64a6f7d8afa83596fafb3afa218c3 - languageName: node - linkType: hard - -"@protobufjs/fetch@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/fetch@npm:1.1.0" - dependencies: - "@protobufjs/aspromise": "npm:^1.1.1" - "@protobufjs/inquire": "npm:^1.1.0" - checksum: 10/67ae40572ad536e4ef94269199f252c024b66e3059850906bdaee161ca1d75c73d04d35cd56f147a8a5a079f5808e342b99e61942c1dae15604ff0600b09a958 - languageName: node - linkType: hard - -"@protobufjs/float@npm:^1.0.2": - version: 1.0.2 - resolution: "@protobufjs/float@npm:1.0.2" - checksum: 10/634c2c989da0ef2f4f19373d64187e2a79f598c5fb7991afb689d29a2ea17c14b796b29725945fa34b9493c17fb799e08ac0a7ccaae460ee1757d3083ed35187 - languageName: node - linkType: hard - -"@protobufjs/inquire@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/inquire@npm:1.1.0" - checksum: 10/c09efa34a5465cb120775e1a482136f2340a58b4abce7e93d72b8b5a9324a0e879275016ef9fcd73d72a4731639c54f2bb755bb82f916e4a78892d1d840bb3d2 - languageName: node - linkType: hard - -"@protobufjs/path@npm:^1.1.2": - version: 1.1.2 - resolution: "@protobufjs/path@npm:1.1.2" - checksum: 10/bb709567935fd385a86ad1f575aea98131bbd719c743fb9b6edd6b47ede429ff71a801cecbd64fc72deebf4e08b8f1bd8062793178cdaed3713b8d15771f9b83 - languageName: node - linkType: hard - -"@protobufjs/pool@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/pool@npm:1.1.0" - checksum: 10/b9c7047647f6af28e92aac54f6f7c1f7ff31b201b4bfcc7a415b2861528854fce3ec666d7e7e10fd744da905f7d4aef2205bbcc8944ca0ca7a82e18134d00c46 - languageName: node - linkType: hard - -"@protobufjs/utf8@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/utf8@npm:1.1.0" - checksum: 10/131e289c57534c1d73a0e55782d6751dd821db1583cb2f7f7e017c9d6747addaebe79f28120b2e0185395d990aad347fb14ffa73ef4096fa38508d61a0e64602 - languageName: node - linkType: hard - "@rollup/plugin-commonjs@npm:^19.0.0": version: 19.0.2 resolution: "@rollup/plugin-commonjs@npm:19.0.2" @@ -3576,7 +3298,7 @@ __metadata: languageName: node linkType: hard -"@types/node@npm:*, @types/node@npm:>=13.7.0, @types/node@npm:^22.13.1": +"@types/node@npm:*, @types/node@npm:^22.13.1": version: 22.13.10 resolution: "@types/node@npm:22.13.10" dependencies: @@ -4930,33 +4652,13 @@ __metadata: languageName: node linkType: hard -"color-name@npm:^1.0.0, color-name@npm:~1.1.4": +"color-name@npm:~1.1.4": version: 1.1.4 resolution: "color-name@npm:1.1.4" checksum: 10/b0445859521eb4021cd0fb0cc1a75cecf67fceecae89b63f62b201cca8d345baf8b952c966862a9d9a2632987d4f6581f0ec8d957dfacece86f0a7919316f610 languageName: node linkType: hard -"color-string@npm:^1.9.0": - version: 1.9.1 - resolution: "color-string@npm:1.9.1" - dependencies: - color-name: "npm:^1.0.0" - simple-swizzle: "npm:^0.2.2" - checksum: 10/72aa0b81ee71b3f4fb1ac9cd839cdbd7a011a7d318ef58e6cb13b3708dca75c7e45029697260488709f1b1c7ac4e35489a87e528156c1e365917d1c4ccb9b9cd - languageName: node - linkType: hard - -"color@npm:^4.2.3": - version: 4.2.3 - resolution: "color@npm:4.2.3" - dependencies: - color-convert: "npm:^2.0.1" - color-string: "npm:^1.9.0" - checksum: 10/b23f5e500a79ea22428db43d1a70642d983405c0dd1f95ef59dbdb9ba66afbb4773b334fa0b75bb10b0552fd7534c6b28d4db0a8b528f91975976e70973c0152 - languageName: node - linkType: hard - "colorette@npm:^2.0.20": version: 2.0.20 resolution: "colorette@npm:2.0.20" @@ -5377,7 +5079,7 @@ __metadata: languageName: node linkType: hard -"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.3": +"detect-libc@npm:^2.0.0": version: 2.0.3 resolution: "detect-libc@npm:2.0.3" checksum: 10/b4ea018d623e077bd395f168a9e81db77370dde36a5b01d067f2ad7989924a81d31cb547ff764acb2aa25d50bb7fdde0b0a93bec02212b0cb430621623246d39 @@ -6506,13 +6208,6 @@ __metadata: languageName: node linkType: hard -"flatbuffers@npm:^1.12.0": - version: 1.12.0 - resolution: "flatbuffers@npm:1.12.0" - checksum: 10/cab05829660c89e01e4074cb07e3d1d79c1955e278221866f9e7ef28d5de89852f83a84084e4e83bac6bfac65108a261f9da36f5034a3145d8dc013c9959ed12 - languageName: node - linkType: hard - "flatted@npm:^3.2.9": version: 3.3.3 resolution: "flatted@npm:3.3.3" @@ -6945,13 +6640,6 @@ __metadata: languageName: node linkType: hard -"guid-typescript@npm:^1.0.9": - version: 1.0.9 - resolution: "guid-typescript@npm:1.0.9" - checksum: 10/829dd87866800a5138aafa0873994028bbc446eb20ff4cae6452d471a2a3d26f7025bed3eb980692c0f022fd22f95ea7396122b46b45a4b5084958505a4fc50c - languageName: node - linkType: hard - "has-bigints@npm:^1.0.2": version: 1.1.0 resolution: "has-bigints@npm:1.1.0" @@ -7284,13 +6972,6 @@ __metadata: languageName: node linkType: hard -"is-arrayish@npm:^0.3.1": - version: 0.3.2 - resolution: "is-arrayish@npm:0.3.2" - checksum: 10/81a78d518ebd8b834523e25d102684ee0f7e98637136d3bdc93fd09636350fa06f1d8ca997ea28143d4d13cb1b69c0824f082db0ac13e1ab3311c10ffea60ade - languageName: node - linkType: hard - "is-async-function@npm:^2.0.0": version: 2.1.1 resolution: "is-async-function@npm:2.1.1" @@ -8213,13 +7894,6 @@ __metadata: languageName: node linkType: hard -"long@npm:^5.0.0, long@npm:^5.2.3": - version: 5.2.4 - resolution: "long@npm:5.2.4" - checksum: 10/c27c060a683d4d76dc48da12ded0ae49c610aaf10d028ec938829d7bebe916979dcc8b67ed71f8bf6d845a90151b66a9b741a3ee51ec874908e496c2a576697a - languageName: node - linkType: hard - "loose-envify@npm:^1.1.0, loose-envify@npm:^1.4.0": version: 1.4.0 resolution: "loose-envify@npm:1.4.0" @@ -9193,45 +8867,6 @@ __metadata: languageName: node linkType: hard -"onnxruntime-common@npm:1.20.1": - version: 1.20.1 - resolution: "onnxruntime-common@npm:1.20.1" - checksum: 10/242ee8ad2fde620a4d1ea64501fa23b4fbd95c3c8a816969e12321e37c4b6c642c1043308b371c8ebed19784a0b9f3526182e20a2d87b9ca3753b79918b143c7 - languageName: node - linkType: hard - -"onnxruntime-common@npm:1.21.0-dev.20241212-1f88284f96": - version: 1.21.0-dev.20241212-1f88284f96 - resolution: "onnxruntime-common@npm:1.21.0-dev.20241212-1f88284f96" - checksum: 10/c58ce123223841758fc89cca63fe1b64970352f26c64fc5249d106fa86db379f1ebae1ea635d94f0e4ef78111d7f317a084c4e7eba556dad1d070194e0a5a166 - languageName: node - linkType: hard - -"onnxruntime-node@npm:1.20.1": - version: 1.20.1 - resolution: "onnxruntime-node@npm:1.20.1" - dependencies: - onnxruntime-common: "npm:1.20.1" - tar: "npm:^7.0.1" - checksum: 10/4104d62beae79a884c5ff940887eea711f1634af2b2df64fe2d00c893be1a41ae1992176147e3f5b2bb4be5efb09975e7cbe820d52c2d32c81e386536a27d3e6 - conditions: (os=win32 | os=darwin | os=linux) - languageName: node - linkType: hard - -"onnxruntime-web@npm:1.21.0-dev.20250114-228dd16893": - version: 1.21.0-dev.20250114-228dd16893 - resolution: "onnxruntime-web@npm:1.21.0-dev.20250114-228dd16893" - dependencies: - flatbuffers: "npm:^1.12.0" - guid-typescript: "npm:^1.0.9" - long: "npm:^5.2.3" - onnxruntime-common: "npm:1.21.0-dev.20241212-1f88284f96" - platform: "npm:^1.3.6" - protobufjs: "npm:^7.2.4" - checksum: 10/bb0cf8d868ff24b186b928791a46dd78840cc59f6540aa4fd12c2db78a889f7164ff3f075995aed9fe2f93f558359a874b62403aa38c0b6527c2fceb434b9462 - languageName: node - linkType: hard - "openai@npm:^4.77.0": version: 4.82.0 resolution: "openai@npm:4.82.0" @@ -9610,13 +9245,6 @@ __metadata: languageName: node linkType: hard -"platform@npm:^1.3.6": - version: 1.3.6 - resolution: "platform@npm:1.3.6" - checksum: 10/1f2d8333e23ea6a7620c828d2fc1ccbbd33e01928fb142323420506114d7325ebdeb1b38544efbf64e90ab73af0847f874d0f475b9327bcf53510fa827a4ef95 - languageName: node - linkType: hard - "playwright-core@npm:1.50.1": version: 1.50.1 resolution: "playwright-core@npm:1.50.1" @@ -9874,26 +9502,6 @@ __metadata: languageName: node linkType: hard -"protobufjs@npm:^7.2.4": - version: 7.4.0 - resolution: "protobufjs@npm:7.4.0" - dependencies: - "@protobufjs/aspromise": "npm:^1.1.2" - "@protobufjs/base64": "npm:^1.1.2" - "@protobufjs/codegen": "npm:^2.0.4" - "@protobufjs/eventemitter": "npm:^1.1.0" - "@protobufjs/fetch": "npm:^1.1.0" - "@protobufjs/float": "npm:^1.0.2" - "@protobufjs/inquire": "npm:^1.1.0" - "@protobufjs/path": "npm:^1.1.2" - "@protobufjs/pool": "npm:^1.1.0" - "@protobufjs/utf8": "npm:^1.1.0" - "@types/node": "npm:>=13.7.0" - long: "npm:^5.0.0" - checksum: 10/408423506610f70858d7593632f4a6aa4f05796c90fd632be9b9252457c795acc71aa6d3b54bb7f48a890141728fee4ca3906723ccea6c202ad71f21b3879b8b - languageName: node - linkType: hard - "prr@npm:~1.0.1": version: 1.0.1 resolution: "prr@npm:1.0.1" @@ -10633,75 +10241,6 @@ __metadata: languageName: node linkType: hard -"sharp@npm:^0.33.5": - version: 0.33.5 - resolution: "sharp@npm:0.33.5" - dependencies: - "@img/sharp-darwin-arm64": "npm:0.33.5" - "@img/sharp-darwin-x64": "npm:0.33.5" - "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" - "@img/sharp-libvips-darwin-x64": "npm:1.0.4" - "@img/sharp-libvips-linux-arm": "npm:1.0.5" - "@img/sharp-libvips-linux-arm64": "npm:1.0.4" - "@img/sharp-libvips-linux-s390x": "npm:1.0.4" - "@img/sharp-libvips-linux-x64": "npm:1.0.4" - "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" - "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" - "@img/sharp-linux-arm": "npm:0.33.5" - "@img/sharp-linux-arm64": "npm:0.33.5" - "@img/sharp-linux-s390x": "npm:0.33.5" - "@img/sharp-linux-x64": "npm:0.33.5" - "@img/sharp-linuxmusl-arm64": "npm:0.33.5" - "@img/sharp-linuxmusl-x64": "npm:0.33.5" - "@img/sharp-wasm32": "npm:0.33.5" - "@img/sharp-win32-ia32": "npm:0.33.5" - "@img/sharp-win32-x64": "npm:0.33.5" - color: "npm:^4.2.3" - detect-libc: "npm:^2.0.3" - semver: "npm:^7.6.3" - dependenciesMeta: - "@img/sharp-darwin-arm64": - optional: true - "@img/sharp-darwin-x64": - optional: true - "@img/sharp-libvips-darwin-arm64": - optional: true - "@img/sharp-libvips-darwin-x64": - optional: true - "@img/sharp-libvips-linux-arm": - optional: true - "@img/sharp-libvips-linux-arm64": - optional: true - "@img/sharp-libvips-linux-s390x": - optional: true - "@img/sharp-libvips-linux-x64": - optional: true - "@img/sharp-libvips-linuxmusl-arm64": - optional: true - "@img/sharp-libvips-linuxmusl-x64": - optional: true - "@img/sharp-linux-arm": - optional: true - "@img/sharp-linux-arm64": - optional: true - "@img/sharp-linux-s390x": - optional: true - "@img/sharp-linux-x64": - optional: true - "@img/sharp-linuxmusl-arm64": - optional: true - "@img/sharp-linuxmusl-x64": - optional: true - "@img/sharp-wasm32": - optional: true - "@img/sharp-win32-ia32": - optional: true - "@img/sharp-win32-x64": - optional: true - checksum: 10/9f153578cb02735359cbcc874f52b56b8074ed997498c35255c7099d4f4f506f6ddf83a437a55242c7ad4f979336660504b6c78e29d6933f4981dedbdae5ce09 - languageName: node - linkType: hard - "shebang-command@npm:^2.0.0": version: 2.0.0 resolution: "shebang-command@npm:2.0.0" @@ -10814,15 +10353,6 @@ __metadata: languageName: node linkType: hard -"simple-swizzle@npm:^0.2.2": - version: 0.2.2 - resolution: "simple-swizzle@npm:0.2.2" - dependencies: - is-arrayish: "npm:^0.3.1" - checksum: 10/c6dffff17aaa383dae7e5c056fbf10cf9855a9f79949f20ee225c04f06ddde56323600e0f3d6797e82d08d006e93761122527438ee9531620031c08c9e0d73cc - languageName: node - linkType: hard - "simple-wcswidth@npm:^1.0.1": version: 1.0.1 resolution: "simple-wcswidth@npm:1.0.1" @@ -11383,7 +10913,7 @@ __metadata: languageName: node linkType: hard -"tar@npm:^7.0.1, tar@npm:^7.4.3": +"tar@npm:^7.4.3": version: 7.4.3 resolution: "tar@npm:7.4.3" dependencies: From 671ace2e4644a94dff47cca28198df4e40d02d56 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 17:58:56 -0400 Subject: [PATCH 52/55] fix e2e test --- packages/nodejs/test/e2e/kernel-worker.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/nodejs/test/e2e/kernel-worker.test.ts b/packages/nodejs/test/e2e/kernel-worker.test.ts index f93dd6daf..5041ce924 100644 --- a/packages/nodejs/test/e2e/kernel-worker.test.ts +++ b/packages/nodejs/test/e2e/kernel-worker.test.ts @@ -33,7 +33,7 @@ describe('Kernel Worker', () => { kernelPort.close(); } kernelPort = new NodeMessageChannel().port1; - kernel = await makeKernel(kernelPort); + kernel = await makeKernel({ port: kernelPort }); }); afterEach(async () => { From 01b658a910d58e3b8a75304252fe8b2deadb4826 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 21:31:48 -0400 Subject: [PATCH 53/55] added auto-served version of demo:rag:ci --- packages/nodejs/package.json | 1 + packages/nodejs/scripts/demo-rag-ci.sh | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+) create mode 100755 packages/nodejs/scripts/demo-rag-ci.sh diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 5eca2f6e5..1b290a6c2 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -24,6 +24,7 @@ "changelog:validate": "../../scripts/validate-changelog.sh @ocap/nodejs", "clean": "rimraf --glob './*.tsbuildinfo' ./.eslintcache ./coverage ./dist", "demo:rag": "node ./dist/demo/rag/run.mjs", + "demo:rag:ci": "./scripts/demo-rag-ci.sh", "demo:console": "node ./dist/demo/console/run.mjs", "lint": "yarn lint:eslint && yarn lint:misc --check && yarn constraints && yarn lint:dependencies", "lint:dependencies": "depcheck", diff --git a/packages/nodejs/scripts/demo-rag-ci.sh b/packages/nodejs/scripts/demo-rag-ci.sh new file mode 100755 index 000000000..21886266c --- /dev/null +++ b/packages/nodejs/scripts/demo-rag-ci.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash + +set -x +set -e +set -o pipefail + +# We borrow the vat definition from extension for now +yarn ocap bundle "src/demo/rag/vats" + +# Start the server in background and capture its PID +yarn ocap serve "src/demo/rag/vats" & +SERVER_PID=$! + +function cleanup() { + # Kill the server if it's still running + if kill -0 $SERVER_PID 2>/dev/null; then + kill $SERVER_PID + fi +} +# Ensure we always close the server +trap cleanup EXIT + +yarn demo:rag From 8390d55a06d931c4c8e51745934d66ba38c49cd7 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 23:50:27 -0400 Subject: [PATCH 54/55] add but do not use ref~reader --- packages/nodejs/package.json | 5 + packages/nodejs/src/interfaces.ts | 100 +++ packages/nodejs/src/reader-ref.ts | 100 +++ packages/nodejs/src/ref-reader.ts | 52 ++ packages/nodejs/src/types.ts | 1108 +++++++++++++++++++++++++++++ yarn.lock | 5 + 6 files changed, 1370 insertions(+) create mode 100644 packages/nodejs/src/interfaces.ts create mode 100644 packages/nodejs/src/reader-ref.ts create mode 100644 packages/nodejs/src/ref-reader.ts create mode 100644 packages/nodejs/src/types.ts diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 1b290a6c2..27f099156 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -41,8 +41,13 @@ "test:watch": "vitest --config vitest.config.ts" }, "dependencies": { + "@endo/base64": "^1.0.9", "@endo/eventual-send": "^1.2.6", + "@endo/exo": "^1.5.8", + "@endo/far": "^1.1.9", "@endo/marshal": "^1.6.2", + "@endo/pass-style": "^1.4.7", + "@endo/patterns": "^1.4.8", "@endo/promise-kit": "^1.1.6", "@endo/stream": "^1.2.6", "@langchain/core": "^0.3.37", diff --git a/packages/nodejs/src/interfaces.ts b/packages/nodejs/src/interfaces.ts new file mode 100644 index 000000000..a318ee1e0 --- /dev/null +++ b/packages/nodejs/src/interfaces.ts @@ -0,0 +1,100 @@ +// @ts-check + +import { M } from '@endo/patterns'; + +export const WorkerInterface = M.interface('EndoWorker', {}); + +export const HostInterface = M.interface( + 'EndoHost', + {}, + { defaultGuards: 'passable' }, +); + +export const GuestInterface = M.interface( + 'EndoGuest', + {}, + { defaultGuards: 'passable' }, +); + +export const InvitationInterface = M.interface( + 'EndoInvitation', + {}, + { defaultGuards: 'passable' }, +); + +export const InspectorHubInterface = M.interface( + 'EndoInspectorHub', + {}, + { defaultGuards: 'passable' }, +); + +export const InspectorInterface = M.interface( + `EndoInspector`, + {}, + { defaultGuards: 'passable' }, +); + +export const BlobInterface = M.interface( + 'EndoBlobInterface', + {}, + { defaultGuards: 'passable' }, +); + +export const ResponderInterface = M.interface( + 'EndoResponder', + {}, + { + defaultGuards: 'passable', + }, +); + +export const EnvelopeInterface = M.interface('EndoEnvelope', {}); + +export const DismisserInterface = M.interface( + 'EndoDismisser', + {}, + { defaultGuards: 'passable' }, +); + +export const HandleInterface = M.interface( + 'EndoHandle', + {}, + { + defaultGuards: 'passable', + }, +); + +export const DirectoryInterface = M.interface( + 'EndoDirectory', + {}, + { + defaultGuards: 'passable', + }, +); + +export const DaemonFacetForWorkerInterface = M.interface( + 'EndoDaemonFacetForWorker', + {}, +); + +export const WorkerFacetForDaemonInterface = M.interface( + 'EndoWorkerFacetForDaemon', + {}, + { defaultGuards: 'passable' }, +); + +export const EndoInterface = M.interface( + 'Endo', + {}, + { + defaultGuards: 'passable', + }, +); + +export const AsyncIteratorInterface = M.interface( + 'AsyncIterator', + {}, + { + defaultGuards: 'passable', + }, +); diff --git a/packages/nodejs/src/reader-ref.ts b/packages/nodejs/src/reader-ref.ts new file mode 100644 index 000000000..1c6a6e781 --- /dev/null +++ b/packages/nodejs/src/reader-ref.ts @@ -0,0 +1,100 @@ +// @ts-check + +import { encodeBase64 } from '@endo/base64'; +import { makeExo } from '@endo/exo'; +import type { FarRef } from '@endo/far'; +import { mapReader } from '@endo/stream'; +import type { Reader, Stream } from '@endo/stream'; + +import { AsyncIteratorInterface } from './interfaces.ts'; +import type { SomehowAsyncIterable } from './types.ts'; + +/** + * Returns the iterator for the given iterable object. + * Supports both synchronous and asynchronous iterables. + * + * @param iterable - An iterable object. + * @template Item The item type of the iterable. + * @returns An async iterator. + */ +export const asyncIterate = ( + iterable: SomehowAsyncIterable, +): AsyncIterableIterator => { + let iterator: AsyncIterator; + + if (Symbol.asyncIterator in iterable) { + iterator = (iterable as AsyncIterable)[Symbol.asyncIterator](); + } else if (Symbol.iterator in iterable) { + iterator = { + next: async () => (iterable as Iterable)[Symbol.iterator]().next(), + [Symbol.asyncIterator]() { + return this; + }, + } as AsyncIterator; + } else if ('next' in iterable) { + const syncIterator = iterable as { next: () => IteratorResult }; + iterator = { + next: async () => syncIterator.next(), + [Symbol.asyncIterator]() { + return this; + }, + } as AsyncIterator; + } else { + throw new Error('Invalid iterable provided'); + } + + return iterator as AsyncIterableIterator; +}; + +/** + * Creates a reference to an async iterator that can be used across vat boundaries. + * + * @param iterable - An iterable object. + * @template Item The item type of the iterable. + * @returns A reference to an async iterator. + */ +export const makeIteratorRef = ( + iterable: SomehowAsyncIterable, +): FarRef> => { + const iterator = asyncIterate(iterable); + + return makeExo('AsyncIterator', AsyncIteratorInterface, { + async next(): Promise> { + return iterator.next(); + }, + + async return(value?: unknown): Promise> { + if (iterator.return !== undefined) { + return iterator.return(value); + } + return harden({ done: true, value: undefined }); + }, + + async throw(error: Error): Promise> { + if (iterator.throw !== undefined) { + return iterator.throw(error); + } + return harden({ done: true, value: undefined }); + }, + + [Symbol.asyncIterator]() { + return this; + }, + }); +}; + +/** + * Creates a reference to a reader that converts a Uint8Array stream to base64 strings. + * + * @param readable - A stream of Uint8Arrays. + * @returns A reader that emits base64 strings. + */ +export const makeReaderRef = ( + readable: SomehowAsyncIterable, +): FarRef> => + makeIteratorRef( + mapReader( + asyncIterate(readable) as Stream, + encodeBase64, + ), + ); diff --git a/packages/nodejs/src/ref-reader.ts b/packages/nodejs/src/ref-reader.ts new file mode 100644 index 000000000..5a95f7424 --- /dev/null +++ b/packages/nodejs/src/ref-reader.ts @@ -0,0 +1,52 @@ +import { decodeBase64 } from '@endo/base64'; +import { makeExo } from '@endo/exo'; +import { E } from '@endo/far'; +import type { ERef } from '@endo/far'; +import { mapReader } from '@endo/stream'; +import type { Stream } from '@endo/stream'; + +import { AsyncIteratorInterface } from './interfaces.ts'; + +/** + * Creates a reference to an async iterator that can be used across vat boundaries. + * + * @param iteratorRef - A reference to an async iterator. + * @template TValue The type of the values in the iterator. + * @template TReturn The type of the return value of the iterator. + * @template TNext The type of the next value of the iterator. + * @returns A reference to an async iterator. + */ +export const makeRefIterator = ( + iteratorRef: ERef>, +): Stream => { + const iterator = makeExo('AsyncIterator', AsyncIteratorInterface, { + async next(value: undefined): Promise> { + return E(iteratorRef).next(value); + }, + + async return(value: undefined): Promise> { + return E(iteratorRef).return(value); + }, + + async throw(error: Error): Promise> { + return E(iteratorRef).throw(error); + }, + + [Symbol.asyncIterator]() { + return this; + }, + }); + + return iterator; +}; + +/** + * Creates a reference to a reader that can be used across vat boundaries. + * + * @param readerRef - A reference to a reader. + * @returns A reference to a reader. + */ +export const makeRefReader = ( + readerRef: ERef>, +): AsyncIterableIterator => + mapReader(makeRefIterator(readerRef), decodeBase64); diff --git a/packages/nodejs/src/types.ts b/packages/nodejs/src/types.ts new file mode 100644 index 000000000..e00c69874 --- /dev/null +++ b/packages/nodejs/src/types.ts @@ -0,0 +1,1108 @@ +import type { ERef } from '@endo/eventual-send'; +import type { FarRef } from '@endo/far'; +import type { Passable } from '@endo/pass-style'; +import type { Reader, Writer, Stream } from '@endo/stream'; + +export type SomehowAsyncIterable = + | AsyncIterable + | Iterable + | { next: () => IteratorResult }; + +export type Config = { + statePath: string; + ephemeralStatePath: string; + cachePath: string; + sockPath: string; +}; + +export type Sha512 = { + update: (chunk: Uint8Array) => void; + updateText: (chunk: string) => void; + digestHex: () => string; +}; + +export type Connection = { + reader: Reader; + writer: Writer; + closed: Promise; +}; + +export type HttpRequest = { + method: string; + url: string; + headers: Record; +}; + +export type HttpResponse = { + status: number; + headers: Record; + content: AsyncIterable | string | Uint8Array | undefined; +}; + +export type HttpRespond = (request: HttpRequest) => Promise; +export type HttpConnect = ( + connection: Connection, + request: HttpRequest, +) => void; + +export type MignonicPowers = { + connection: { + reader: Reader; + writer: Writer; + }; +}; + +type IdRecord = { + number: string; + node: string; +}; + +type EndoFormula = { + type: 'endo'; + networks: string; + peers: string; + host: string; + leastAuthority: string; +}; + +type LoopbackNetworkFormula = { + type: 'loopback-network'; +}; + +type WorkerFormula = { + type: 'worker'; +}; + +export type WorkerDeferredTaskParams = { + workerId: string; +}; + +/** + * Deferred tasks parameters for `host` and `guest` formulas. + */ +export type AgentDeferredTaskParams = { + agentId: string; + handleId: string; +}; + +type HostFormula = { + type: 'host'; + handle: string; + worker: string; + inspector: string; + petStore: string; + endo: string; + networks: string; +}; + +type GuestFormula = { + type: 'guest'; + handle: string; + hostHandle: string; + hostAgent: string; + petStore: string; + worker: string; +}; + +type LeastAuthorityFormula = { + type: 'least-authority'; +}; + +type MarshalFormula = { + type: 'marshal'; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + body: any; + slots: string[]; +}; + +type EvalFormula = { + type: 'eval'; + worker: string; + source: string; + names: string[]; // lexical names + values: string[]; // formula identifiers + // TODO formula slots +}; + +export type MarshalDeferredTaskParams = { + marshalFormulaNumber: string; + marshalId: string; +}; + +export type EvalDeferredTaskParams = { + endowmentIds: string[]; + evalId: string; + workerId: string; +}; + +type ReadableBlobFormula = { + type: 'readable-blob'; + content: string; +}; + +export type ReadableBlobDeferredTaskParams = { + readableBlobId: string; +}; + +type LookupFormula = { + type: 'lookup'; + + /** + * The formula identifier of the naming hub to call lookup on. + * A "naming hub" is an object with a variadic `lookup()` method. + */ + hub: string; + + /** + * The pet name path. + */ + path: string[]; +}; + +type MakeUnconfinedFormula = { + type: 'make-unconfined'; + worker: string; + powers: string; + specifier: string; + // TODO formula slots +}; + +type MakeBundleFormula = { + type: 'make-bundle'; + worker: string; + powers: string; + bundle: string; + // TODO formula slots +}; + +export type MakeCapletDeferredTaskParams = { + capletId: string; + powersId: string; + workerId: string; +}; + +type PeerFormula = { + type: 'peer'; + networks: string; + node: string; + addresses: string[]; +}; + +type HandleFormula = { + type: 'handle'; + agent: string; +}; + +type KnownPeersStoreFormula = { + type: 'known-peers-store'; +}; + +type PetStoreFormula = { + type: 'pet-store'; +}; + +type PetInspectorFormula = { + type: 'pet-inspector'; + petStore: string; +}; + +type DirectoryFormula = { + type: 'directory'; + petStore: string; +}; + +type InvitationFormula = { + type: 'invitation'; + hostAgent: string; // identifier + hostHandle: string; // identifier + guestName: string; +}; + +export type InvitationDeferredTaskParams = { + invitationId: string; +}; + +export type Formula = + | EndoFormula + | LoopbackNetworkFormula + | WorkerFormula + | HostFormula + | GuestFormula + | LeastAuthorityFormula + | MarshalFormula + | EvalFormula + | ReadableBlobFormula + | LookupFormula + | MakeUnconfinedFormula + | MakeBundleFormula + | HandleFormula + | PetInspectorFormula + | KnownPeersStoreFormula + | PetStoreFormula + | DirectoryFormula + | PeerFormula + | InvitationFormula; + +export type Builtins = { + // eslint-disable-next-line @typescript-eslint/naming-convention + NONE: string; + // eslint-disable-next-line @typescript-eslint/naming-convention + MAIN: string; +}; + +export type Specials = { + [specialName: string]: (builtins: Builtins) => Formula; +}; + +export type Responder = { + respondId(id: string | Promise): void; +}; + +export type Request = { + type: 'request'; + description: string; + responder: ERef; + settled: Promise<'fulfilled' | 'rejected'>; +}; + +export type Package = { + type: 'package'; + strings: string[]; // text that appears before, between, and after named formulas. + names: string[]; // edge names + ids: string[]; // formula identifiers +}; + +export type Message = Request | Package; + +export type EnvelopedMessage = Message & { + to: string; + from: string; +}; + +export type Dismisser = { + dismiss(): void; +}; + +export type StampedMessage = EnvelopedMessage & { + number: number; + date: string; + dismissed: Promise; + dismisser: ERef; +}; + +export type Invitation = { + accept(guestHandleId: string): Promise; +}; + +export type Topic< + TRead, + TWrite = undefined, + TReadReturn = undefined, + TWriteReturn = undefined, +> = { + publisher: Stream; + subscribe(): Stream; +}; + +/** + * The cancellation context of a live value associated with a formula. + */ +export type Context = { + /** + * The identifier for the associated formula. + */ + id: string; + /** + * Cancel the value, preparing it for garbage collection. Cancellation + * propagates to all values that depend on this value. + * + * @param reason - The reason for the cancellation. + * @param logPrefix - The prefix to use within the log. + * @returns A promise that is resolved when the value is cancelled and + * can be garbage collected. + */ + cancel: (reason?: Error, logPrefix?: string) => Promise; + + /** + * A promise that is rejected when the context is cancelled. + * Once rejected, the cancelled value may initiate any teardown procedures. + */ + cancelled: Promise; + + /** + * A promise that is resolved when the context is disposed. This occurs + * after the `cancelled` promise is rejected, and after all disposal hooks + * have been run. + * Once resolved, the value may be garbage collected at any time. + */ + disposed: Promise; + + /** + * @param id - The formula identifier of the value whose + * cancellation should cause this value to be cancelled. + */ + thisDiesIfThatDies: (id: string) => void; + + /** + * @param id - The formula identifier of the value that should + * be cancelled if this value is cancelled. + */ + thatDiesIfThisDies: (id: string) => void; + + /** + * @param hook - A hook to run when the value is cancelled. + */ + onCancel: (hook: () => void | Promise) => void; +}; + +export type FarContext = { + id: () => string; + cancel: (reason: Error) => Promise; + whenCancelled: () => Promise; + whenDisposed: () => Promise; + addDisposalHook: Context['onCancel']; +}; + +export type Controller = { + value: Promise; + context: Context; +}; + +export type FormulaMaker = ( + formula: ThisFormula, + context: Context, + id: string, + number: string, +) => unknown; + +export type FormulaMakerTable = { + [T in Formula['type']]: FormulaMaker<{ type: T } & Formula>; +}; + +// eslint-disable-next-line @typescript-eslint/no-empty-object-type +export type Envelope = {}; + +export type Handle = { + receive(envelope: Envelope, allegedFromId: string): void; + open(envelope: Envelope): EnvelopedMessage; +}; + +export type MakeSha512 = () => Sha512; + +export type PetStoreNameChange = + | { add: string; value: IdRecord } + | { remove: string }; + +export type PetStoreIdNameChange = + | { add: IdRecord; names: string[] } + | { remove: IdRecord; names?: string[] }; + +export type NameChangesTopic = Topic; + +export type IdChangesTopic = Topic; + +export type PetStore = { + has(petName: string): boolean; + identifyLocal(petName: string): string | undefined; + list(): string[]; + /** + * Subscribe to all name changes. First publishes all existing names in alphabetical order. + * Then publishes diffs as names are added and removed. + */ + followNameChanges(): AsyncGenerator; + /** + * Subscribe to name changes for the specified id. First publishes the existing names for the id. + * Then publishes diffs as names are added and removed, or if the id is itself removed. + * + * @throws If attempting to follow an id with no names. + */ + followIdNameChanges( + id: string, + ): AsyncGenerator; + write(petName: string, id: string): Promise; + remove(petName: string): Promise; + rename(fromPetName: string, toPetName: string): Promise; + /** + * @param id The formula identifier to look up. + * @returns The formula identifier for the given pet name, or `undefined` if the pet name is not found. + */ + reverseIdentify(id: string): string[]; +}; + +/** + * `add` and `remove` are locators. + */ +export type LocatorNameChange = + | { add: string; names: string[] } + | { remove: string; names?: string[] }; + +export type NameHub = { + has(...petNamePath: string[]): Promise; + identify(...petNamePath: string[]): Promise; + locate(...petNamePath: string[]): Promise; + reverseLocate(locator: string): Promise; + followLocatorNameChanges( + locator: string, + ): AsyncGenerator; + list(...petNamePath: string[]): Promise; + listIdentifiers(...petNamePath: string[]): Promise; + followNameChanges( + ...petNamePath: string[] + ): AsyncGenerator; + lookup(petNamePath: string | string[]): Promise; + reverseLookup(value: unknown): string[]; + write(petNamePath: string | string[], id: string): Promise; + remove(...petNamePath: string[]): Promise; + move(fromPetName: string[], toPetName: string[]): Promise; + copy(fromPetName: string[], toPetName: string[]): Promise; +}; + +export type EndoDirectory = { + makeDirectory(petNamePath: string[]): Promise; +} & NameHub; + +export type MakeDirectoryNode = (petStore: PetStore) => EndoDirectory; + +export type Mail = { + handle: () => Handle; + // Partial inheritance from PetStore: + petStore: PetStore; + // Mail operations: + listMessages(): Promise; + followMessages(): AsyncGenerator; + resolve(messageNumber: number, resolutionName: string): Promise; + reject(messageNumber: number, message?: string): Promise; + adopt( + messageNumber: number, + edgeName: string, + petName: string[], + ): Promise; + dismiss(messageNumber: number): Promise; + request( + recipientName: string, + what: string, + responseName: string, + ): Promise; + send( + recipientName: string, + strings: string[], + edgeNames: string[], + petNames: string[], + ): Promise; + deliver(message: EnvelopedMessage): void; +}; + +export type MakeMailbox = (args: { + selfId: string; + petStore: PetStore; + directory: EndoDirectory; + context: Context; +}) => Mail; + +export type RequestFn = ( + what: string, + responseName: string, + guestId: string, + guestPetStore: PetStore, +) => Promise; + +export type EndoReadable = { + sha512(): string; + streamBase64(): FarRef>; + text(): Promise; + json(): Promise; +}; +// eslint-disable-next-line @typescript-eslint/no-empty-object-type +export type EndoWorker = {}; + +export type MakeHostOrGuestOptions = { + agentName?: string; + introducedNames?: Record; +}; + +export type EndoPeer = { + provide: (id: string) => Promise; +}; + +export type EndoGateway = { + provide: (id: string) => Promise; +}; + +export type EndoGreeter = { + hello: ( + remoteNodeKey: string, + remoteGateway: Promise, + cancel: (error: Error) => void, + cancelled: Promise, + ) => Promise; +}; + +export type PeerInfo = { + node: string; + addresses: string[]; +}; + +export type EndoNetwork = { + supports: (network: string) => boolean; + addresses: () => string[]; + connect: (address: string, farContext: FarContext) => Promise; +}; + +export type EndoAgent = { + // eslint-disable-next-line @typescript-eslint/no-empty-object-type + handle: () => {}; + listMessages: Mail['listMessages']; + followMessages: Mail['followMessages']; + resolve: Mail['resolve']; + reject: Mail['reject']; + adopt: Mail['adopt']; + dismiss: Mail['dismiss']; + request: Mail['request']; + send: Mail['send']; + deliver: Mail['deliver']; + /** + * @param id The formula identifier to look up. + * @returns The formula identifier for the given pet name, or `undefined` if the pet name is not found. + */ + reverseIdentify(id: string): string[]; +} & EndoDirectory; + +export type EndoGuest = {} & EndoAgent; + +export type FarEndoGuest = FarRef; + +export type EndoHost = { + storeBlob( + readerRef: ERef>, + petName: string, + ): Promise>; + storeValue( + value: Value, + petName: string | string[], + ): Promise; + provideGuest( + petName?: string, + opts?: MakeHostOrGuestOptions, + ): Promise; + provideHost( + petName?: string, + opts?: MakeHostOrGuestOptions, + ): Promise; + makeDirectory(petNamePath: string[]): Promise; + provideWorker(petNamePath: string[]): Promise; + evaluate( + workerPetName: string | undefined, + source: string, + codeNames: string[], + petNames: string[], + resultName?: string[], + ): Promise; + makeUnconfined( + workerName: string | undefined | 'MAIN', + specifier: string, + powersName: string | 'NONE' | 'SELF' | 'ENDO', + resultName?: string, + ): Promise; + makeBundle( + workerPetName: string | undefined, + bundleName: string, + powersName: string, + resultName?: string, + ): Promise; + cancel(petName: string, reason: Error): Promise; + greeter(): Promise; + gateway(): Promise; + getPeerInfo(): Promise; + addPeerInfo(peerInfo: PeerInfo): Promise; + invite(guestName: string): Promise; + accept( + invitationId: string, + guestHandleId: string, + guestName: string, + ): Promise; +} & EndoAgent; + +export type EndoHostController = {} & Controller>; + +export type EndoInspector = { + lookup: (petName: Record) => Promise; + list: () => Record[]; +}; + +export type KnownEndoInspectors = { + eval: EndoInspector<'endowments' | 'source' | 'worker'>; + 'make-unconfined': EndoInspector<'host'>; + 'make-bundle': EndoInspector<'bundle' | 'powers' | 'worker'>; + guest: EndoInspector<'bundle' | 'powers'>; +} & Record; + +export type EndoBootstrap = { + ping: () => Promise; + terminate: () => Promise; + host: () => Promise; + leastAuthority: () => Promise; + greeter: () => Promise; + gateway: () => Promise; + reviveNetworks: () => Promise; + addPeerInfo: (peerInfo: PeerInfo) => Promise; +}; + +export type CryptoPowers = { + makeSha512: () => Sha512; + randomHex512: () => Promise; +}; + +export type FilePowers = { + makeFileReader: (path: string) => Reader; + makeFileWriter: (path: string) => Writer; + writeFileText: (path: string, text: string) => Promise; + readFileText: (path: string) => Promise; + maybeReadFileText: (path: string) => Promise; + readDirectory: (path: string) => Promise; + makePath: (path: string) => Promise; + joinPath: (...components: string[]) => string; + removePath: (path: string) => Promise; + renamePath: (source: string, target: string) => Promise; +}; + +export type AssertValidNameFn = (name: string) => void; + +export type PetStorePowers = { + makeIdentifiedPetStore: ( + id: string, + formulaType: 'pet-store' | 'known-peers-store', + assertValidName: AssertValidNameFn, + ) => Promise; +}; + +export type SocketPowers = { + servePort: (args: { + port: number; + host?: string; + cancelled: Promise; + }) => Promise<{ + port: number; + connections: Reader; + }>; + connectPort: (args: { + port: number; + host?: string; + cancelled: Promise; + }) => Promise; + servePath: (args: { + path: string; + cancelled: Promise; + }) => Promise>; +}; + +export type NetworkPowers = SocketPowers & { + makePrivatePathService: ( + endoBootstrap: FarRef, + sockPath: string, + cancelled: Promise, + exitWithError: (error: Error) => void, + ) => { started: Promise; stopped: Promise }; +}; + +export type DaemonicPersistencePowers = { + initializePersistence: () => Promise; + provideRootNonce: () => Promise<{ + rootNonce: string; + isNewlyCreated: boolean; + }>; + makeContentSha512Store: () => { + store: (readable: AsyncIterable) => Promise; + fetch: (sha512: string) => EndoReadable; + }; + readFormula: (formulaNumber: string) => Promise; + writeFormula: (formulaNumber: string, formula: Formula) => Promise; +}; + +// eslint-disable-next-line @typescript-eslint/no-empty-object-type +export type DaemonWorkerFacet = {}; + +export type WorkerDaemonFacet = { + terminate(): Promise; + evaluate( + source: string, + names: string[], + values: unknown[], + id: string, + cancelled: Promise, + ): Promise; + makeBundle( + bundle: ERef, + powers: ERef, + context: ERef, + ): Promise; + makeUnconfined( + path: string, + powers: ERef, + context: ERef, + ): Promise; +}; + +export type DaemonicControlPowers = { + makeWorker: ( + id: string, + daemonWorkerFacet: DaemonWorkerFacet, + cancelled: Promise, + ) => Promise<{ + workerTerminated: Promise; + workerDaemonFacet: ERef; + }>; +}; + +export type DaemonicPowers = { + crypto: CryptoPowers; + petStore: PetStorePowers; + persistence: DaemonicPersistencePowers; + control: DaemonicControlPowers; +}; + +type FormulateResult = Promise<{ + id: string; + value: Item; +}>; + +export type DeferredTask> = ( + ids: Readonly, +) => Promise; + +/** + * A collection of deferred tasks (i.e. async functions) that can be executed in + * parallel. + */ +export type DeferredTasks> = { + execute(identifiers: Readonly): Promise; + push(value: DeferredTask): void; +}; + +type FormulateNumberedGuestParams = { + guestFormulaNumber: string; + handleId: string; + guestId: string; + hostAgentId: string; + hostHandleId: string; + storeId: string; + workerId: string; +}; + +type FormulateHostDependenciesParams = { + endoId: string; + networksDirectoryId: string; + specifiedWorkerId?: string; +}; + +type FormulateNumberedHostParams = { + hostFormulaNumber: string; + hostId: string; + handleId: string; + workerId: string; + storeId: string; + inspectorId: string; + endoId: string; + networksDirectoryId: string; +}; + +export type FormulaValueTypes = { + directory: EndoDirectory; + network: EndoNetwork; + peer: EndoGateway; + 'pet-store': PetStore; + 'readable-blob': EndoReadable; + endo: EndoBootstrap; + guest: EndoGuest; + handle: Handle; + host: EndoHost; + invitation: Invitation; + worker: EndoWorker; +}; + +export type ProvideTypes = FormulaValueTypes & { + agent: EndoAgent; + hub: NameHub; +}; + +export type Provide = < + Type extends keyof ProvideTypes, + Provided extends ProvideTypes[Type], +>( + id: string, + expectedType?: Type, +) => Promise; + +export type DaemonCore = { + cancelValue: (id: string, reason: Error) => Promise; + + formulate: ( + formulaNumber: string, + formula: Formula, + ) => Promise<{ + id: string; + value: unknown; + }>; + + formulateBundle: ( + hostAgentId: string, + hostHandleId: string, + bundleId: string, + deferredTasks: DeferredTasks, + specifiedWorkerId?: string, + specifiedPowersId?: string, + ) => FormulateResult; + + formulateDirectory: () => FormulateResult; + + formulateEndo: ( + specifiedFormulaNumber: string, + ) => FormulateResult>; + + formulateMarshalValue: ( + value: Passable, + deferredTasks: DeferredTasks, + ) => FormulateResult; + + formulateEval: ( + nameHubId: string, + source: string, + codeNames: string[], + endowmentIdsOrPaths: (string | string[])[], + deferredTasks: DeferredTasks, + specifiedWorkerId?: string, + ) => FormulateResult; + + formulateGuest: ( + hostId: string, + hostHandleId: string, + deferredTasks: DeferredTasks, + ) => FormulateResult; + + /** + * Helper for callers of {@link formulateNumberedGuest}. + * + * @param hostId - The formula identifier of the host to formulate a guest for. + * @returns The formula identifiers for the guest formulation's dependencies. + */ + formulateGuestDependencies: ( + hostAgentId: string, + hostHandleId: string, + ) => Promise>; + + formulateHost: ( + endoId: string, + networksDirectoryId: string, + deferredTasks: DeferredTasks, + specifiedWorkerId?: string | undefined, + ) => FormulateResult; + + /** + * Helper for callers of {@link formulateNumberedHost}. + * + * @param specifiedIdentifiers - The existing formula identifiers specified to the host formulation. + * @returns The formula identifiers for all of the host formulation's dependencies. + */ + formulateHostDependencies: ( + specifiedIdentifiers: FormulateHostDependenciesParams, + ) => Promise>; + + formulateLoopbackNetwork: () => FormulateResult; + + formulateNetworksDirectory: () => FormulateResult; + + formulateNumberedGuest: ( + identifiers: FormulateNumberedGuestParams, + ) => FormulateResult; + + formulateNumberedHost: ( + identifiers: FormulateNumberedHostParams, + ) => FormulateResult; + + formulatePeer: ( + networksId: string, + nodeId: string, + addresses: string[], + ) => FormulateResult; + + formulateReadableBlob: ( + readerRef: ERef>, + deferredTasks: DeferredTasks, + ) => FormulateResult>; + + formulateInvitation: ( + hostAgentId: string, + hostHandleId: string, + guestName: string, + deferredTasks: DeferredTasks, + ) => FormulateResult; + + formulateUnconfined: ( + hostAgentId: string, + hostHandleId: string, + specifier: string, + deferredTasks: DeferredTasks, + specifiedWorkerId?: string, + specifiedPowersId?: string, + ) => FormulateResult; + + formulateWorker: ( + deferredTasks: DeferredTasks, + ) => FormulateResult; + + getAllNetworkAddresses: (networksDirectoryId: string) => Promise; + + getIdForRef: (ref: unknown) => string | undefined; + + getTypeForId: (id: string) => Promise; + + makeDirectoryNode: MakeDirectoryNode; + + makeMailbox: MakeMailbox; + + provide: Provide; + + provideController: (id: string) => Controller; + + provideAgentForHandle: (id: string) => Promise>; +}; + +export type DaemonCoreExternal = { + formulateEndo: DaemonCore['formulateEndo']; + nodeId: string; + provide: DaemonCore['provide']; +}; + +export type SerialJobs = { + enqueue: (asyncFn?: () => Promise) => Promise; +}; + +export type Multimap = { + /** + * @param key - The key to add a value for. + * @param value - The value to add. + */ + add(key: Key, value: Value): void; + + /** + * @param key - The key whose value to delete. + * @param value - The value to delete. + * @returns `true` if the key was found and the value was deleted, `false` otherwise. + */ + delete(key: Key, value: Value): boolean; + + /** + * @param key - The key whose values to delete + * @returns `true` if the key was found and its values were deleted, `false` otherwise. + */ + deleteAll(key: Key): boolean; + + /** + * @param key - The key whose first value to retrieve + * @returns The first value associated with the key. + */ + get(key: Key): Value | undefined; + + /** + * @param key - The key whose values to retrieve. + * @returns An array of all values associated with the key. + */ + getAllFor(key: Key): Value[]; + + /** + * @param key - The key whose presence to check for. + * @returns `true` if the key is present and `false` otherwise. + */ + has(key: Key): boolean; +}; + +/** + * A multimap backed by a WeakMap. + */ +export type WeakMultimap = Multimap; + +export type BidirectionalMultimap = { + /** + * @param key - The key to add a value for. + * @param value - The value to add. + * @throws If the value has already been added for a different key. + */ + add(key: Key, value: Value): void; + + /** + * @param key - The key whose value to delete. + * @param value - The value to delete. + * @returns `true` if the key was found and the value was deleted, `false` otherwise. + */ + delete(key: Key, value: Value): boolean; + + /** + * @param key - The key whose values to delete. + * @returns `true` if the key was found and its values were deleted, `false` otherwise. + */ + deleteAll(key: Key): boolean; + + /** + * @param key - The key whose presence to check for. + * @returns `true` if the key is present and `false` otherwise. + */ + has(key: Key): boolean; + + /** + * @param value - The value whose presence to check for. + * @returns `true` if the value is present and `false` otherwise. + */ + hasValue(value: Value): boolean; + + /** + * @param key - The key whose first value to retrieve. + * @returns The first value associated with the key. + */ + get(key: Key): Value | undefined; + + /** + * @param value - The value whose key to retrieve. + * @returns The key associated with the value. + */ + getKey(value: Value): Key | undefined; + + /** + * @returns An array of all values, for all keys. + */ + getAll(): Value[]; + + /** + * @param key - The key whose values to retrieve. + * @returns An array of all values associated with the key. + */ + getAllFor(key: Key): Value[]; +}; + +export type RemoteControl = { + accept( + remoteGateway: Promise, + cancel: (error: Error) => void | Promise, + cancelled: Promise, + dispose?: () => void, + ): void; + connect( + getRemoteGateway: () => Promise, + cancel: (error: Error) => void | Promise, + cancelled: Promise, + dispose?: () => void, + ): Promise; +}; + +export type RemoteControlState = { + accept( + remoteGateway: Promise, + cancel: (error: Error) => void | Promise, + cancelled: Promise, + dispose: () => void, + ): RemoteControlState; + connect( + getRemoteGateway: () => Promise, + cancel: (error: Error) => void | Promise, + cancelled: Promise, + dispose: () => void, + ): { state: RemoteControlState; remoteGateway: Promise }; +}; diff --git a/yarn.lock b/yarn.lock index c1e04936c..e9f6d61ba 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2260,8 +2260,13 @@ __metadata: resolution: "@ocap/nodejs@workspace:packages/nodejs" dependencies: "@arethetypeswrong/cli": "npm:^0.17.3" + "@endo/base64": "npm:^1.0.9" "@endo/eventual-send": "npm:^1.2.6" + "@endo/exo": "npm:^1.5.8" + "@endo/far": "npm:^1.1.9" "@endo/marshal": "npm:^1.6.2" + "@endo/pass-style": "npm:^1.4.7" + "@endo/patterns": "npm:^1.4.8" "@endo/promise-kit": "npm:^1.1.6" "@endo/stream": "npm:^1.2.6" "@langchain/core": "npm:^0.3.37" From ee310977525abf217641ceebec6d155ea7525065 Mon Sep 17 00:00:00 2001 From: grypez <143971198+grypez@users.noreply.github.com> Date: Wed, 12 Mar 2025 23:53:49 -0400 Subject: [PATCH 55/55] moderninze console demo --- packages/nodejs/package.json | 1 + packages/nodejs/scripts/demo-console-ci.sh | 23 +++++++++++++++++++ .../src/demo/console/vats/asyncGenerator.js | 4 ++-- 3 files changed, 26 insertions(+), 2 deletions(-) create mode 100755 packages/nodejs/scripts/demo-console-ci.sh diff --git a/packages/nodejs/package.json b/packages/nodejs/package.json index 27f099156..c76f0ff9f 100644 --- a/packages/nodejs/package.json +++ b/packages/nodejs/package.json @@ -26,6 +26,7 @@ "demo:rag": "node ./dist/demo/rag/run.mjs", "demo:rag:ci": "./scripts/demo-rag-ci.sh", "demo:console": "node ./dist/demo/console/run.mjs", + "demo:console:ci": "./scripts/demo-console-ci.sh", "lint": "yarn lint:eslint && yarn lint:misc --check && yarn constraints && yarn lint:dependencies", "lint:dependencies": "depcheck", "lint:eslint": "eslint . --cache", diff --git a/packages/nodejs/scripts/demo-console-ci.sh b/packages/nodejs/scripts/demo-console-ci.sh new file mode 100755 index 000000000..2e351f5b0 --- /dev/null +++ b/packages/nodejs/scripts/demo-console-ci.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash + +set -x +set -e +set -o pipefail + +# We borrow the vat definition from extension for now +yarn ocap bundle "src/demo/console/vats" + +# Start the server in background and capture its PID +yarn ocap serve "src/demo/console/vats" & +SERVER_PID=$! + +function cleanup() { + # Kill the server if it's still running + if kill -0 $SERVER_PID 2>/dev/null; then + kill $SERVER_PID + fi +} +# Ensure we always close the server +trap cleanup EXIT + +yarn demo:console diff --git a/packages/nodejs/src/demo/console/vats/asyncGenerator.js b/packages/nodejs/src/demo/console/vats/asyncGenerator.js index c76fa310c..38ed748a6 100644 --- a/packages/nodejs/src/demo/console/vats/asyncGenerator.js +++ b/packages/nodejs/src/demo/console/vats/asyncGenerator.js @@ -22,7 +22,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { const counters = new Map(); - const { readStreamFacet, makeStream, removeStream } = makeStreamMaker(); + const { readStreamFacet, makeStream } = makeStreamMaker(); const makeCounter = (start = 0, ms = 100) => { const { id, writer } = makeStream(); @@ -61,7 +61,7 @@ export function buildRootObject(vatPowers, parameters, _baggage) { async stop(counterId) { verbose && logger.debug(`stopping [${counterId}]`); await getCounter(counterId).stop(); - return removeStream(counterId); + return true; }, }); }